Reading variables from a configuration file - c++

Question

I'm trying to determine the best way to read in a configuration file. This "Parameters.cfg" file is just to define values and is of this form:
origin_uniform_distribution 0
origin_defined 1
angles_gaussian 0
angles_uniform_distribution 0
angles_defined 0
startx 0
starty 0
gap 500
nevents 1000
origin_uniform_distribution_x_min -5
origin_uniform_distribution_x_max 5
origin_uniform_distribution_y_min -5
origin_uniform_distribution_y_max 5
origin_defined_x 0
origin_defined_y 0
angles_gaussian_center 0
angles_gaussian_sigma 5
angles_uniform_distribution_x_min -5
angles_uniform_distribution_x_max 5
angles_uniform_distribution_y_min -5
angles_uniform_distribution_y_max 5
angles_defined_x 10
angles_defined_y 10
The names are there for the user to know which variables they are defining. I would like to have my program read in only the actual numbers and skip over the strings. I know I can do this in a way where I define a whole lot of strings in my program, and then just leave them sitting there defined but obviously unused. Is there a way to read in the numbers easily while skipping over the strings?

Answer 1

What's wrong with the obvious solution?
string param_name;
int param_value;
while ( fin >> param_name >> param_value )
{
..
}
You can discard the param_name after each iteration while storing the param_value wherever you need it.

Answer 2

When you read out the strings, just don't store them anywhere:
std::vector<int> values;
std::string discard;
int value;
while (file >> discard >> value) {
values.push_back(value);
}

Answer 3

I guess I must be overdue to post a ctype facet to ignore the strings and read only the data we care about:
#include <locale>
#include <fstream>
#include <vector>
#include <iostream>
#include <algorithm>
#include <iterator>
struct number_only: std::ctype<char> {
number_only() : std::ctype<char>(get_table()) {}
static mask const *get_table() {
static std::vector<mask> rc(table_size, space);
std::fill_n(&rc['0'], 10, digit);
rc['-'] = punct;
return &rc[0];
}
};
int main() {
// open the file
std::ifstream x("config.txt");
// have the file use our ctype facet:
x.imbue(std::locale(std::locale(), new number_only));
// initialize vector from the numbers in the file:
std::vector<int> numbers((std::istream_iterator<int>(x)),
std::istream_iterator<int>());
// display what we read:
std::copy(numbers.begin(), numbers.end(),
std::ostream_iterator<int>(std::cout, "\n"));
return 0;
}
This way the extraneous data is really and truly ignored -- after imbuing the stream with our facet, it's as if the strings don't exist at all.

Answer 4

This method doesn't store the string at all (like was asked for in the question):
static const std::streamsize max = std::numeric_limits<std::streamsize>::max();
std::vector<int> values;
int value;
while(file.ignore(max, ' ') >> file >> value)
{
values.push_back(value);
}
It uses ignore instead of reading the string and not using it.

Answer 5

You can define a structure and then overload the istream operator>> for it:
struct ParameterDiscardingName {
int value;
operator int() const {
return value;
}
};
istream& operator>>(istream& is, ParameterDiscardingName& param) {
std::string discard;
return is >> discard >> param.value;
}
ifstream file("Parameters.cfg");
istream_iterator<ParameterDiscardingName> begin(file), end;
vector<int> parameters(begin, end);