Autor
|
Tema: [c++11] ¿Como pasar n argumentos a una función? (Leído 3,729 veces)
|
carl0s_47
Desconectado
Mensajes: 2
|
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
|
|
|
En línea
|
|
|
|
class_OpenGL
Desconectado
Mensajes: 437
Si usas Direct3D, no eres mi amigo :P
|
Yo tampoco sé el nombre de los tres puntos, pero el tema va así: Existe una librería de C (por lo que también está para C++) que se llama cstdarg. Esta es la que te permite pasar n parámetros. Cuando pasas un número indeterminado de parámetros, la función no sabe cuántos parámetros hay o de qué tipo son, además no sabe donde comienzan en memoria por lo que esas tres cosas se deberían indicar con un parámetro de la función. Por ejemplo, voy a hacer una función que acepte n parámetros y que haga la media aritmética: #include <iostream> #include <cstdarg> // La función solo aceptará doubles, así que el tipo viene implícito en la función. // La dirección de memoria de los parámetros la sabes gracias al último parámetro // (el que hay antes de los ...). En este caso, num_elementos. Esto implica que al menos // necesitar un parámetro en la función (en este caso, num_elementos). double MediaAritmetica(int num_elementos, ...) { va_list parametros; double parametro_actual; double media; int i; va_start(parametros, num_elementos); // Inicializamos 'parametros' usando el último parámetro. for(i = 0; i < num_elementos; i++) { parametro_actual = va_arg(parametros, double); // Obtenemos el siguiente parámetro, de tipo double. media += parametro_actual; } media /= num_elementos; va_end(parametros); // No sé muy bien por qué, pero esta línea es necesaria. return media; } int main() { double media; media = MediaAritmetica(4, 3.2, 1.1, 4.3, 2.0); std::cout << media << std::endl; return 0; }
|
|
|
En línea
|
| Programador aficionado. Me quiero centrar en programar videojuegos. La API que uso para crearlos es OpenGL |
|
|
|
|
MAFUS
Desconectado
Mensajes: 1.603
|
Lo más sensato sería que representaras el sensor en tu código, así, incluso, te sería más fácil depurar. C, y por ende C++ son lenguajes creados para hablar con la máquina pero muchas veces, sobre todo quien trabaja a más alto nivel olvida o desconoce ese potencial del lenguaje. En tu caso deberías usar los bitfields. En tu ejemplo, para representar el registro CONFIG_0 podrías hacer así: #include <stdio.h> #include <stdlib.h> typedef enum { DIVIDE_BY_2, DIVIDE_BY_4, DIVIDE_BY_8, /* Default value */ DIVIDE_BY_16, DIVIDE_BY_32, DIVIDE_BY_64, DIVIDE_BY_128, DIVIDE_BY_256 } prescaler; struct { unsigned TX_FREQ_DIV : 3; unsigned NUM_TX : 5; } CONFIG_0; /* Aquí otros registros struct { unsigned <campo> : <tamaño en bits>; unsigned <campo> : <tamaño en bits>; ... } <nombre del registro> ... */ int main() { CONFIG_0.TX_FREQ_DIV = DIVIDE_BY_8; CONFIG_0.NUM_TX = 5; puts("CONFIG_0 register status"); puts("------------------------"); printf("TX_FREQ_DIV : %u\n", CONFIG_0. TX_FREQ_DIV); printf("NUM_TX : %u\n", CONFIG_0. NUM_TX); }
|
|
|
En línea
|
|
|
|
ivancea96
Desconectado
Mensajes: 3.412
ASMático
|
Si pones un ejemplo del código en el que uses los métodos de la clase m_register, se me despejarían algunas dudas. No estoy seguro de que realmente te interese una función variadic. Si quieres comprimir los 3setters y los 3 getters en 1 setter y 1 getter, podrías meter los 3 maps en un array (o en una std::list si te interesa que sea una cantidad de maps variable (o std::vector, vaya, según necesidades)), y en los setters/getters, recibir como parámetro el índice del map.
Si aun quieres utilizar un método variadic, ver un ejemplo de uso sería muy explicativo. Y por cierto, ¿qué valores almacenas exactamente en el map?
|
|
|
En línea
|
|
|
|
carl0s_47
Desconectado
Mensajes: 2
|
Que tal, Por ahora utilizo la clase solo para llenar de información a la ventana, la primer parte del constructor MainWindow le paso la información al grupo CONFIG_0, con la clase paso la información a CONFIG_0_c. #include "mainwindow.h" #include "ui_mainwindow.h" #include <QDebug> #include <QString> #include <map> #include "m_register.h" MainWindow::MainWindow(QWidget *parent) : QMainWindow(parent), ui(new Ui::MainWindow) { ui->setupUi(this); ui->groupBox->setTitle("CONFIG_0"); ui->label->setText("NUM_TX"); ui->label_2->setText("TX_FREQ_DIV"); const std::map<int, QString> NUM_TX{{0, "0 Pulses"}, {1, "1 Pulse"}, {2, "2 Pulses"}, {3, "3 Pulse"}, {4, "4 Pulses"}, {5, "5 Pulses"}, {6, "6 Pulses"}, {7, "7 Pulse"}, {8, "8 Pulses"}, {9, "9 Pulse"}, {10, "10 Pulses"}, {11, "11 Pulses"}, {12, "12 Pulses"}, {13, "13 Pulse"}, {14, "14 Pulses"}, {16, "16 Pulse"}, {17, "17 Pulses"}, {18, "18 Pulses"}, {19, "19 Pulses"}, {20, "20 Pulse"}, {21, "21 Pulses"}, {22, "22 Pulse"}, {23, "23 Pulses"}, {24, "24 Pulses"}, {25, "25 Pulses"}, {26, "26 Pulse"}, {27, "27 Pulses"}, {28, "28 Pulse"}, {29, "29 Pulses"}, {30, "30 Pulses"}, {31, "31 Pulses"}, {32, "32 Pulse"}, {33, "33 Pulses"}, {34, "34 Pulse"}, {35, "35 Pulses"}}; const std::map<int, QString> TX_FREQ_DIV{{0, "Divide by 2"}, {1, "Divide by 4"}, {2, "Divide by 8"}, {3, "Divide by 16"}, {4, "Divide by 32"}, {5, "Divide by 64"}, {6, "Divide by 128"}, {7, "Divide by 256"}}; for(auto const& it : NUM_TX){ ui->comboBox->addItem(it.second); } for(auto const& it : TX_FREQ_DIV){ ui->comboBox_2->addItem(it.second); } // Usando la clase m_register m_config_0{"CONFIG_0_c"}; m_config_0.setField_1(NUM_TX); m_config_0.setField_2(TX_FREQ_DIV); ui->groupBox_2->setTitle(m_config_0.getName()); ui->label_3->setText("NUM_TX_c"); ui->label_4->setText("TX_DIV_DIV_c"); for(auto const& it : m_config_0.getField_1()){ ui->comboBox_3->addItem(it.second); } for(auto const& it : m_config_0.getField_2()){ ui->comboBox_4->addItem(it.second); } } MainWindow::~MainWindow() { delete ui; }
Me falta añadir una variable que guarde la locación del campo (a partir de que bit empieza), entonces podría hacer un struct con el std::map y la posición, y en la clase m_register tener un vector de este struct. Saludos
|
|
|
En línea
|
|
|
|
ivancea96
Desconectado
Mensajes: 3.412
ASMático
|
Ya que lso números son contiguos de 0 a N, en vez de un map, tal vez te interese utilizar un vector o una list.
A parte de eso, sobre el método variadic, lo dicho. Si puedes, pon un ejemplo de cómo usarías el método variadic con una cantidad indefinida de argumentos. No digo que lo hagas, sinó que lo utilices como si existiera para saber qué quieres hacer con él.
|
|
|
En línea
|
|
|
|
|
Mensajes similares |
|
Asunto |
Iniciado por |
Respuestas |
Vistas |
Último mensaje |
|
|
manejo de argumentos en funcion dentro de funcion ???
PHP
|
SpiderNet
|
2
|
3,590
|
30 Septiembre 2008, 03:01 am
por SpiderNet
|
|
|
Pasar nombre de funcion como parametro de otra funcion en java
Java
|
xGisKaRDx
|
3
|
10,325
|
1 Agosto 2014, 23:27 pm
por jhonatanAsm
|
|
|
Como pasar argumentos por linea de comandos en wxWidgets
Programación C/C++
|
Noxware
|
6
|
4,903
|
3 Diciembre 2014, 09:00 am
por Eternal Idol
|
|
|
Pasar argumentos a una función externa de C desde NASM
« 1 2 »
ASM
|
huchoko
|
10
|
6,700
|
28 Febrero 2019, 03:43 am
por srWhiteSkull
|
|
|
Pasar argumentos a una función saliendo de una caja de texto con <Enter>.
Scripting
|
El mas antiguo
|
2
|
4,835
|
12 Febrero 2022, 13:51 pm
por El mas antiguo
|
|