Getter that loops through the variables of a struct - c++

Question

There's a small program that has various options, and these need some input values -- they are in a struct. Each option requires an instance of the struct, so there's an array of struct. I would like to be able to save these options at program exit and read them at program start. But the struct doesn't hold only 3 variables, and they may grow in time as my small program grows. An example of the struct:
struct S
{
int a;
float b;
std::vector<float> c;
}
The save file has as many rows as there are options, and each row contins the same sequence, but different values, which are separated by ;, the elements of the vectors with , and a terminating ;, no spaces. For the above example:
13;3.14;0.618,1.618;
7;2.718;12.3,45.6;
...
But the file can get corrupt, so reading it corrupts the variables and the program crashes. Currently, reading the numbers involves a loop (the number of options/rows is known):
float x;
char c;
std::fstream fs;
// file open, flags, etc
fs >> a >> c;
if(c != ';')
{
std::cerr << "Error! ...\n";
break;
}
fs >> b >> c;
if(c != ';')
{
std::cerr << "Error! ...\n";
break;
}
c = ','; // make sure c is not ';'
while(c != ';')
{
fs >> x >> c;
c.push_back(x);
if(c != ',')
{
std::err << "Error...\n";
break;
}
}
Instead of break it can be an abort() function, or one that starts from scratch, not the problem, but if there are 100 variables, I have to do this for everyone. That's why I was thinking of looping through them. Apparently there's no "reflection" in C++, but it could be done via some macros. Currently, I don't understand either of them, so I tried my own solution. First, I tried making a general use() function with a template, but it fails when called, with template argument deduction/substitution failed. I tried auto as the type, but also fails. I suppose it makes sense. So then I thought why not just make a set/get that handles the worst possible type and converts it, internally. This is what member functions came up:
enum { INT_A, FLOAT_B, VECTOR_C, ALL };
void set(const int &n, const float &f, const int &i = 0)
{
switch(n)
{
case INT_A: a = static_cast<int>(x); break;
case FLOAT_B: b = x; break;
case VECTOR_C: c[i] = x; break;
}
}
float get(const int &n, const int &i = 0)
{
switch(n)
{
case INT_A: return static_cast<float>(a); break;
case FLOAT_B: return b; break;
case VECTOR_C: return c[i]; break;
}
}
get() is mostly for confirming, set() is what interests me. It does seem to work, I can set up a loop to iterate and automate the process, but is this a good solution (I somehow doubt it is, but I am not advanced)? Are there better ones that do not involve external libraries?
Sorry for the delay, I simply forgot to update it. I decided to use an additional std::vector<float> that holds all the variables as float. The order is that the original std::vector<float> (c in the above example) are all, sequentially, last in the vector. The downside is that it occupies about twice as much memory, but less code. Now, I know that the vector c (and the rest in the real case scenario) have a minimum length, so I have two options:
impose the length if the additional vector to include these minimum lengths, then, when it's about writing, I need an if() deciding whether I need to write until the minimum length, or above it, something like this:
if(c.size() < minLength)
// loop to write to c[i]
else
// loop to c.push_back(...)
or I could just consider the length of the additional vector made of the number of single variables, like a and b, and considering the length of the vector (c) zero, thus, when writing, the code will reduce to a for() or while() loop with push_back().
I opted for the second, so the struct now looks like this:
struct S
{
int a;
float b;
std::vector<float> c;
std::vector<float> additional(2); // holds a and b, c islength zero
}
The writing to vector can be easily implemented in a loop. A quick show looks like this:
int n;
float x;
char c;
while(n < maxSizeOfAdditional)
{
switch(n)
{
case 1: a = static_cast<int>(additional[i]); break;
case 2: b = additional[i]; break;
case 3:
{
while(fs >> x >> c)
// loop for writing c.push_back(x)
}
}
++n;
}
I need the original types because of the rest of the code in the program, thus the need for static_cast. It works now, and there is no "reflection", nor did I need one, I just needed a way to automate the process with a loop.
Still, I don't know if it's an "orthodox" approach. For my part, it seems to have solved my problem, but I don't know how something like this would be considered. Better yet, I don't know how "the usual" way is done with programs that need to read/write variables to savefiles, variables that must reside somewhere (I just imagined them in a struct, that's all). I suppose time will tell.