Re: Static tables initialization in C++
On 2008-02-01, Jerry Coffin <jcoffin@taeus.com> wrote:
In article <slrnfq6a98.kc1.stefano.sabatini@geppetto.reilabs.com>,
stefano.sabatini@caos.org says...
[ ... ]
class Color {
ColorId id;
string str;
Color(ColorId _id, string _str) { id= _id; str= _str; }
It doesn't make any real difference to what you're discussing, but the
generally preferred form would be:
Color(ColorID _id, string _str) : id(_id), str(_str) {}
There are also enough rules restricting the use of leading underscored
in your own code that many people advise against using them at all.
Mmh.., OK (well another convenction encourages to use m_Foo for object
(Member) fields).
Please could you make an example of a rule restricting the use of
underscored variables in such a context?
static Color Colors[] = {
[green] = { green, "green"},
[blue] = { blue, "blue"},
[red] = { red, "red" },
[yellow] = { yellow, "yellow"}
As you've guessed below, C++ doesn't support this syntax.
It seems the [enum val] = notation isn't unrecognized.
So my question is: how can I initialize in C++ a static table putting
object in a predefined position?
Is the above requirement (the creation of a static table containing
all the colors definition, that is containing all the definitions of
the Color object which will be used in the program) a meaningful one
or there are better mechanisms to achieve the same result in C++?
"Better" is really a question of values. Under the circumstances, your
values are contiguous, so a definition like:
static Color Colors[] = {
{ green, "green"},
{ blue, "blue"},
{ red, "red" },
{ yellow, "yellow"}
};
works perfectly well (i.e. produces the correct result). The compiler
will accept it, which most consider a really good thing. In theory, at
some point in the future you might want to use some non-contiguous
values, for which this is not nearly as well suited.
Tested it, and while the corresponding C contruct is accepted by my
compiler, it doesn't do it with the above construct.
That is while:
typedef struct Color {
enum ColorId id;
char *str;
} Color;
static Color Colors[] = {
[green] = { green, "green"},
[blue] = { blue, "blue"},
[red] = { red, "red" },
[yellow] = { yellow, "yellow"}
};
with the corresponding C++ code:
class Color {
public:
ColorId id;
string str;
Color(ColorId _id, string _str) : id(_id), str(_str) {}
};
static Color map_init[] = {
{ green, "green"},
{ blue, "blue"},
{ red, "red" },
{ yellow, "yellow"}
};
it complains saying:
make Colors
g++ -I/home/stefano/include/ Colors.cpp -o Colors
Colors.cpp:23: error: braces around scalar initializer for type 2?Color2"
If it's certain, or even extremely likely, that you're dealing with a
relatively sparse array, you can easily use a map. This would be useful
if (for example) the color numbers were really RGB values for those
colors:
enum color_values {
red = 0xff0000,
green = 0x00ff00,
blue = 0x0000ff,
yellow = 0xffff00
};
static Color map_init[] = {
// same as Colors[] above
};
#define elements(array) (sizeof(array)/(sizeof(array[0])))
std::map<unsigned long, std::string>
Colors(map_init, map_init+elements(map_init));
You can use array syntax to insert new names as well:
unsigned long cyan = 0x00ffff;
unsigned long magenta = 0xff00ff;
Colors[cyan] = "Cyan";
Colors[magenta] = "Magenta";
Looking up existing colors _can_ be done the same way, with the proviso
that if you try to look up something that hasn't been inserted yet, this
will create an empty Color object and insert it at that point -- IOW, it
works fine if you know everything you look up has been inserted, but can
be a problem if you're trying to figure out whether a value has a name
or not. In that kind of situation, you'll generally want to use the
map's find function instead.
Makes sense, I definitively have to check for the map template. Still
I have to figure out how to tackle the initialization problem.
Many thanks for your detailed explanation.
Regards.
--
Stefano Sabatini
Linux user number 337176 (see http://counter.li.org)