Accessing elements of static array by name

Hello,

I have a global static array of structs and want to access a given
element using an identifier. I don't want to use the element subscript,
because it will change if I insert elements before the element I
want to access. In assembler I would simply add a label in front
of the element, but this doesn't work in C++.

The following programm snippet might explain what I want to do:

#include <iostream>

class A {
public:
const char *s;
};

static A array[] = {
{ "a" },
{ "b" },
// I wish I could just define a label to a given element like this,
// but this syntax is already used for designated inits (at least in gcc):
// element_c:
{ "c" },
{ "d" },
{ "e" },
{ "f" },
{ "g" },
};

int main()
{
// Access element "c"
std::cout << array[2].s << std::endl;

// Now I wish I could write it this:
// std::cout << element_c.s << std::endl;

// Or maybe:
// std::cout << array::element_c.s << std::endl;

return 0;
}

Is there a way to do this in C++ (maybe some preprocessor tricks)?

Thank you.

PS:
This is my first post to usenet, so bear with me.

re: Accessing elements of static array by name

On 2007-08-26 11:20, Paul Brettschneider wrote:There are probably some pre-processor trick you can use, but I suspect
that would be the wrong solution. Since you mentioned assembly I suspect
you have a background with that and might thus not be very familiar with
the C++ way of doing things. If you could explain a little bit about
what you are trying to solve I might be able to give you better advice.

--
Erik Wikström

re: Accessing elements of static array by name

Paul Brettschneider wrote:One C++ way to do this is via references. References can be initialized
by looking up the array using a special function or statically if you
know the index. If the definition of the reference is static then more
than likely the compiler will look it up directly.

As for creating linker labels, you're outa luck. There is very little
chance you can do that portably. There is nothing stopping you however
doing what you want using assembler if your platform supports it.

The code below would solve your issue, and is probably all I would do
until I knew that this solution raises a siginificant problem.

#include <iostream>
#include <cstring>

class A {
public:
const char *s;
bool CompKey( const char * str )
{
return strcmp( str, s ) == 0;
}
};

extern A & element_a;
extern A & element_c;
extern A & element_g;

static A array[] = {
{ "a" },
{ "b" },
// I wish I could just define a label to a given element like this,
// but this syntax is already used for designated inits (at least in gcc):
// element_c:
{ "c" },
{ "d" },
{ "e" },
{ "f" },
{ "g" },
};

template <typename T, int N>
char (&EndOfHelper( T (&)[N] ))[N];
#define EndOf(A) ((A)+sizeof(EndOfHelper(A)))

A & findA( const char * istr )
{
for ( A * i = array; i < EndOf( array ); ++ i )
{
if ( i->CompKey( istr ) )
{
return *i;
}
}
throw "Failed to kind key in array";
}


A & element_a = array[ 0 ];
A & element_c = findA( "c" );
A & element_g = findA( "g" );

int main()
{
// Access element "c"
std::cout << array[2].s << std::endl;

// Now I wish I could write it this:
// std::cout << element_c.s << std::endl;

// Or maybe:
// std::cout << array::element_c.s << std::endl;

return 0;
}

re: Accessing elements of static array by name

On Sun, 26 Aug 2007 11:03:36 +0000, Erik Wikström wrote:
I have, for example, a number of "Server-Objects" which are registered
when connecting to the server and can be used afterwards. When registering
or when generating statistics, it is convenient to loop over an array,
later I want to access them by name.

What I do right now is define global objects and then construct an array
of pointers:

static A element_a = { "a" };
static A element_b = { "b" };
static A element_c = { "c" };

static A *array[] = {
&element_a,
&element_b,
&element_c,
// ...
NULL // sentinel
};

Another possibility is to do it the other way round, like Gianni suggested:
have an array of objects and initialise references with a find()-function
at program-initialisation time.

I was hoping for a more convenient way.

BTW: I think accessing array-elements by name would sometimes be
convenient for local arrays too:

int func()
{
int array[] = {1, element2: 2, 3 };
return element2; // Alias for array[1]
}

Thanks.

re: Accessing elements of static array by name

Paul Brettschneider <paul.brettschneider@yahoo.frwrote in message...A std::map might be an option. Depends on how 'locked-in' you are in your
current design.

// - a loose example -
#include <iostream>
#include <string>
#include <map>

class PaulA{ public:
const char *s;
PaulA() : s(0){}
PaulA( char const *ss ) : s(ss){}
};

int main(){ using std::cout; // for NG post
std::map<std::string, PaulAPaulMap;
PaulMap["a"] = PaulA("a");
PaulMap["b"] = PaulA("because");
PaulMap["c"] = PaulA("c");
std::string key( "d" );
PaulMap[key] = PaulA( key.c_str() );

cout<<" PaulMap[\"a\"] ="<<PaulMap["a"].s<<std::endl;
cout<<" PaulMap[\"b\"] ="<<PaulMap["b"].s<<std::endl;
cout<<" PaulMap[\"c\"] ="<<PaulMap["c"].s<<std::endl;
cout<<" PaulMap[key] ="<<PaulMap[key].s<<std::endl;

std::string keys( "efgh" );
for( size_t i(0); i < keys.size(); ++i ){
std::string tmp( 1, keys.at(i) ); // a bit on the 'ugly' side <G>
PaulMap[ tmp ] = PaulA( tmp.c_str() );
} // for(i)

for( size_t i(0); i < keys.size(); ++i ){
std::string tmp( 1, keys.at(i) );
cout<<" PaulMap["<<tmp<<"] ="
<<PaulMap[tmp].s<<std::endl;
} // for(i)

return 0;
} // main()

/* -output-
PaulMap["a"] =a
PaulMap["b"] =because
PaulMap["c"] =c
PaulMap[key] =d
PaulMap[e] =e
PaulMap[f] =f
PaulMap[g] =g
PaulMap[h] =h
*/

--
Bob R
POVrookie

re: Accessing elements of static array by name

On 2007-08-26 19:10, Paul Brettschneider wrote:You could use std::map<std::string, Aservers. Then you could access a
specific one using servers["the_one"], and you can also loop over all of
them using iterators.
If it's only for a few elements a reference will do, if it's for many
elements perhaps they should not be in an array.

--
Erik Wikström