Russian Qt Forum

C++ (Qt)
struct row
{
    QString name;
    QVariant::Type expectedType;
    void MyData::* fieldOffset;
}

C++ (Qt)
struct Parameters {
    double temperature;
    QString path;
    unsigned someValue;
    // ещё штук 50 параметров
};

C++ (Qt)
struct Parameters {
    double temperature;
    QString path;
    unsigned someValue;
    // ...
};

C++ (Qt)
struct ParameterRow
{
    QString name;
    std::function<QVariant(const Parameters&)> value;
    std::function<void(Parameters&, const QVariant&)> setValue;
};

C++ (Qt)
#include <QString>
#include <QVariant>
#include <QDebug>
 
#include <array>
#include <functional>
 
struct Parameters
{
    double   temperatureX;
    double   temperatureY;
    QString  path;
    unsigned someValue;
};
 
struct ParameterRow
{
    QString name;
    std::function<QVariant(const Parameters&)> value;
    std::function<void(Parameters&, const QVariant&)> setValue;
};
 
static const QString RowSeparator{"----------"};
 
static const std::array<ParameterRow, 5>
ParameterRows{{
    {"Temperature X",
     [](const Parameters& params) { return params.temperatureX; },
     [](Parameters& params, const QVariant& value) { params.temperatureX = value.toDouble(); }},
    {"Temperature Y",
     [](const Parameters& params) { return params.temperatureY; },
     [](Parameters& params, const QVariant& value) { params.temperatureY = value.toDouble(); }},
    {RowSeparator,
     [](const Parameters&) { return QVariant{}; },
     [](Parameters&, const QVariant&) {}},
    {"Result file",
     [](const Parameters& params) { return params.path; },
     [](Parameters& params, const QVariant& value) { params.path = value.toString(); }},
    {"Some value",
     [](const Parameters& params) { return params.someValue; },
     [](Parameters& params, const QVariant& value) { params.someValue = value.toUInt(); }}
}};
 
int main()
{
    Parameters params;
 
    ParameterRows[0].setValue(params, 1000);
    ParameterRows[1].setValue(params, 20);
    ParameterRows[3].setValue(params, "C:\\Windows\\System32");
    ParameterRows[4].setValue(params, 100500);
 
    for (const auto& row:ParameterRows)
        qDebug() << row.name << row.value(params);
 
    return 0;
}

C++ (Qt)
typedef QPair<QString, QVariant> TParam;
typedef QVector<TParam> TParamVec;
 
TParamVec Param2VarVec( const ParameterRow & src );
ParameterRow VarVec2Param( const TParamVec & src );

C++ (Qt)
QVariant GetParamByName( const ParameterRow & row, const QString & name )
{
  if (name == str_Temperature)
   return row.temperature;
 
  if (name == str_Path)
   return row.path;
 
  if (name == str_Value)
   return row.someValue;
 
 Q_ASSERT(0);  // invalid key
 return 0;
}

template<class C> void CInterface::push(C& ptr, const QString& name){
    if(typeid(ptr) == typeid(bool))                  
        записываем в мапу [name] = &ptr, bool;
    else if(typeid(ptr) == typeid(char))             
        записываем в мапу [name] = &ptr, char;
    else if(typeid(ptr) == typeid(short))            
        записываем в мапу [name] = &ptr, short;
	...
}

C++ (Qt)
struct Parameters : public CInterface
{
    double temperature;
    QString path;
    unsigned someValue;
    // ещё штук 50 параметров
    Parameters();
};
Parameters::Parameters() {
    push(temperature, "temperature");
    push(path, "path");
    push(someValue, "someValue");
}

C++ (Qt)
struct CAddress {
    void* address;
    size_t type;
 
    CAddress() {
        address = nullptr;
        type = QMetaType::UnknownType;
    }
 
    CAddress(void* ptr, size_t t) {
        address = ptr;
        type = t;
    }
};
 
class CInterface
{
protected:
    QMap<QString, CAddress> parameters;
public:
    QVariant data(const QString& name);
    void setData(const QString& name, QVariant value);
    template<class C> void push(C& p, const QString& name = QString());
 
};
 
template<class C> void CInterface::push(C& ptr, const QString& name) {
    parameters[name] = CAddress(&ptr, QVariant(ptr).type());
}

C++ (Qt)
QVariant GetParamByID( const ParameterRow & row, ParameterRow::TID ID )
{
 switch (ID) {
  case  ParameterRow::id_Temperature:
   return row.temperature;
 
  case ParameterRow::id_Path:
   return row.path;
 
  case ParameterRow::id_Value:
   return row.someValue;
 
  default:
    Q_ASSERT(0);  // invalid ID
 }
 return 0;
}