Que tal,

Es mi primer pregunta acá, se un poco de C y estoy intentando aprender a programar C++ "moderno" de forma autodidacta y es mi primer proyecto "útil", así que estaré atento a consejos para mejorarlo xD.

Quiero diseñar una GUI (con Qt) con la cual pueda mandarle datos a un microcontrolador por puerto serial, con estos datos se van a configurar varios registros de un sensor que esta conectado al microcontrolador.

El sensor tiene varios registros, cada registro tiene varios campos y cada campo tiene varios valores   que cambian la configuración del sensor, en la siguiente imagen se pueden ver el registro CONFIG_0 y sus campos NUM_TX y TX_FREQ_DIV:



Para representar cada campo del registro utilice un std::map, la llave (key) es el número que se le escribirá al campo en el registro (por ejemplo de 0 a 7 en TX_FREQ_DIV) y el valor (value) es la descripción de cada llave ("Divide by 2", "Divide by 4", etc.), el contenido de cada uno de estos campos los agrego a un combobox de Qt.

Cada registro del sensor puede tener un número diferente de campos, hay registros con dos campos y otros con 3, 4, etc., así que hice una clase básica:

m_register.h

#ifndef M_REGISTER_H
#define M_REGISTER_H
 
#include <QString>
#include <map>
 
class m_register
{
    QString m_Name;
    std::map<int, QString> m_Field_1;
    std::map<int, QString> m_Field_2;
    std::map<int, QString> m_Field_3;
 
public:
    m_register(QString name) : m_Name(name) {}
    QString getName(void) const;
    void setField_1(const std::map<int, QString> field);
    std::map<int, QString> getField_1(void) const;
    void setField_2(const std::map<int, QString> field);
    std::map<int, QString> getField_2(void) const;
    void setField_3(const std::map<int, QString> field);
    std::map<int, QString> getField_3(void) const;
};
 
#endif // M_REGISTER_H
 

m_register.cpp

#include "m_register.h"
 
QString m_register::getName() const
{
    return m_Name;
}
 
void m_register::setField_1(const std::map<int, QString> field)
{
    m_Field_1 = field;
}
 
std::map<int, QString> m_register::getField_1() const
{
    return m_Field_1;
}
 
void m_register::setField_2(const std::map<int, QString> field)
{
    m_Field_2 = field;
}
 
std::map<int, QString> m_register::getField_2() const
{
    return m_Field_2;
}
 
void m_register::setField_3(const std::map<int, QString> field)
{
    m_Field_3 = field;
}
 
std::map<int, QString> m_register::getField_3() const
{
    return m_Field_3;
}
 

Se ve que los métodos setField y getField de cada campo hacen lo mismo, mi duda es si es posible hacer una sola función que acepte n argumentos (n campos) y cree el mismo número de variables de tipo std::map.
¿Podría inicializar un vector sin especificar cuantos elementos contiene y especificar su tamaño en el constructor de m_register?.

He visto que para métodos con número de argumentos variables utilizan ... (olvide el nombre de esos tres puntos) pero no termino de entenderlos, ¿funcionan como argc y argv?

Así va mi GUI xD:


El grupo de arriba es de una prueba que hice sin la clase y el de abajo es una variable de tipo m_register.

Saludos