Is it possible to browse a structure? - c++

Question

I need to fill a structure every 10 mS, in this strucure there are 230 variables, only bool and int. My thinking was first to fill and intialize randomly one by one all the variable. But it's very long to write and seems like very ugly code. Also this structure change often.
So my second thinking was to browse the structure ( maybe using a loop ? ) and fill randomly every variable.
After some research, I can't find anything. So, Is there a way to browse my structure and to fill the variable randomly ?
Thank you for your help.
EDIT : Here's what I try to do :
I've got a header file containing the structure :
typedef struct
{
/// Statut Ground-Flight
int _statutGroundFlight;
/// Statut Capteur de presence
bool _statutCapteurPrensence;
/// Statut Bouton OPEN in
bool _statutBoutonOpenIn;
/// Statut Bouton OPEN ext
bool _statutBoutonOpenExt;
/// Statut Bouton CLOSE in
bool _statutBoutonCloseIn;
/// Statut Bouton CLOSE ext
bool _statutBoutonCloseExt;
...
And here's what I want to do every 10 mS:
//Create a structure
struct myStruct;
//Browse the structure
for(int i; myStruct.size(); ++i){
if(myStruct[i] is int){
//Fill it randomly with int
}
if(mystruct[i] is bool){
//Fill it randomly with bool
}
}

Answer 1

I don't think there is a way to browse the structure and fill the variables as you want, but you can avoid writing codes by using macro.
You can write macro and let the pre-processor to generate the code for you ..
for example:
create one struct.def where you can define required fields
#ifndef INTEGER
#error "INTEGER not defined"
#endif
#ifndef BOOL
#error "BOOL not defined"
#endif
#ifndef create_struct
#error "create_struct not defined"
#endif
create_struct(my_struct,
INTEGER(i1)
BOOL(b1,false)
INTEGER(i2)
INTEGER(i3)
BOOL(b2,true)
BOOL(b3,false)
BOOL(b4,false)
INTEGER(i4)
//add or modify fields here
)
#undef INTEGER
#undef BOOL
#undef create_struct
Then write macro in your code by using above file
#include "stdio.h"
#include "string.h"
//create structure
#define INTEGER(var_name) int var_name;
#define BOOL(var_name,data) bool var_name;
#define create_struct(struct_id,data_type)\
typedef struct struct_id##_tag{\
data_type\
}struct_id;
#include "struct.def"
//-------------------------------------------
//function to initialize default value
#define INTEGER(var_name) p->var_name=0;
#define BOOL(var_name,data) p->var_name=data;
#define create_struct(struct_id,data_type)\
void initialize_##struct_id(struct_id* p)\
{\
data_type\
}
#include "struct.def"
//-------------------------------------------------
//function to fill random value to structure
#define INTEGER(var_name) p->var_name=rand();
#define BOOL(var_name,data) p->var_name=rand()%2;
#define create_struct(struct_id,data_type)\
void fill_random_##struct_id(struct_id* p)\
{\
data_type\
}
#include "struct.def"
//-----------------------------------------
Now if you run preprocessor then it will generate the below mentioned code for you....
typedef struct my_struct_tag{
int i1;
bool b1;
int i2;
int i3;
bool b2;
bool b3;
bool b4;
int i4;
}my_struct;
void initialize_my_struct(my_struct* p) {
p->i1=0;
p->b1=false;
p->i2=0;
p->i3=0;
p->b2=true;
p->b3=false;
p->b4=false;
p->i4=0;
}
void fill_random_my_struct(my_struct* p) {
p->i1=rand();
p->b1=rand()%2;
p->i2=rand();
p->i3=rand();
p->b2=rand()%2;
p->b3=rand()%2;
p->b4=rand()%2;
p->i4=rand();
}
Now, if you want to change your structure then you need to change in only one place that is in struct.def file
You can check the link http://rajenpandit.blogspot.in/p/using-macro.html for further details.

Answer 2

I would opt to use std::map to store values of your members.
class MyStructure
{
std::map< unsigned int, int > integerValues;
std::map< unsigned int, bool > booleanValues;
public:
bool & exampleBoolean = booleanValues[ 0 ];
int & exampleInteger = integerValues[ 0 ];
void randomIntegers() {
for( auto & integer : integerValues )
integer.second = randomInteger(); // put your favorite random here
}
};
This way you will change only the place data is actually stored, not the way that you have accessed your structure.
I would recommend making enum with field names to index a map.

Answer 3

An easy approach is to group the same-type fields, then create a union with type-specific arrays.
Example at ideone.com
#include <iostream>
using namespace std;
union X
{
struct
{
int i1, i2, i3;
bool b1, b2, b3;
};
struct
{
int is[3];
bool bs[3];
};
};
std::ostream& operator<<(std::ostream& os, const X& x)
{
os << "{ ";
for (int i = 0; i < 3; ++i)
os << x.is[i] << ' ' << x.bs[i] << ' ';
return os << '}';
}
int main()
{
for (int i = 0; i < 3; ++i)
{
X x;
for (int j = 0; j < 3; ++j)
{
x.is[j] = rand();
x.bs[j] = rand() % 2;
}
std::cout << x << '\n';
}
}
(Of course you should do something better than hard-coding the array dimensions wherever it's indexed, and allow the number of ints and bools to vary independently, but that's all trivial....)
Sample output:
{ 1804289383 0 1681692777 1 1957747793 1 }
{ 719885386 0 596516649 1 1025202362 1 }
{ 783368690 1 2044897763 0 1365180540 0 }

Answer 4

You cannot iterate over fields of a structure like you want.
If this is for a test, then you should not adapt the structure to suit the test. Instead, just do it the "hard" way - filling each field. This is also important because different fields certainly have different ways of being "random". For example _statutGroundFlight probably cannot be ANY integer value; it probably has a set of valid values to test.