Geek asks and answers

Macro Alternative for C ++ Code Generation

My settings module has a replacement code:

#include <QSettings>

class MySettings
{
public:
    // param1
    void setParam1(QString param1) { _settings.setValue("param1", param1); }
    string param1() { return _settings.value("param1").toString(); }

    // param2
    void setParam2(int param2) { _settings.setValue("param2", param2); }
    int param2() { _settings.value("param2").toInt(); }

    // param3
    void setParam3(int param3) { _settings.setValue("param3", param3); }
    int param3() { _settings.value("param3").toInt(); }

private:
    QSettings _settings;
}

I was able to reduce the amout code for recording using a macro. Here is an example of the type of the QString parameter:

#define INTSETTING(setter, getter) \
    void set##setter(QString getter) { settings.setValue(#getter, getter);} \
    QString getter() {return settings.value(#getter).toString();}

Since I use C ++, I know that using macros is bad, so I'm looking for a cleaner alternative.

I gave an example of Qt (QString), but this is a more general question.

Edit:

What makes the definition of the above class simpler:

class MySettings
{
public:
    STRINGSETTING(Param1, param1)
    INTSETTING(Param2, param2)
    INTSETTING(Param3, param3)

    STRINGSETTING(DefaultTitle, defaultTitle)
    INTSETTING(MaxDocCount, maxDocCount)

private:
    QSettings _settings;
}
+3
source share
3 answers

You can either answer this in a religious way, or return to the old principle: if this makes your code more readable, do it.

, , , , .

, , , , ( , GNU-C).

, , , goto: , , . .

+3

, :

class MySettings
{
public:
    template <size_t N>
    void setParam(QString param) { _settings.setValue(names[N], param); }

    template <size_t N, typename T>
    T param() { return _settings.value(names[N]).toString(); }

private:
    QSettings _settings;
    const char* names[3] = { "param1", "param2", "param3" };
}

, , . settings.setParam<1>("string") settings.param<1, string>(), param1, param2 .. .

, param(), . , MySettings, :

class MySettings
{
    using types = std::tuple<string, int, int>;

public:
    template<size_t N>
    void setParam(QString param) { _settings.setValue(names[N], param); }

    template<size_t N>
    typename std::tuple_element<N, types>::type
    param() { return _settings.value(names[N]).toString(); }

private:
    QSettings _settings;
    const char* names[3] = { "param1", "param2", "param3" };
}

, , . , , - types names.

, , , , setTitle, setColor .., , , . , , , , , . , , , . .

"" toString() param() ( @Joker_vD). :

    template<size_t N>
    typename std::tuple_element<N, types>::type
    param() {
        using T = typename std::tuple_element<N, types>::type;
        return get_value(type<T>(), _settings.value(names[N]));
    }

get_value<T>() - , , QSettings, - ,

 template<typename V>
 string get_value(type<string>, const V& val) { return val.toString(); }

 template<typename V>
 int get_value(type<int>, const V& val) { return val.toInt(); }

type :

 template<typename T>
 struct type { };

QSettings , . , , .

+2

- . / , : setter ( ). public.

+1

More articles:


All Articles