Data statements in C++

[Jerry Evenden]

Just an old C programmer trying to learn a new trick
with C++ so excuse the dumb question:

The use of the "map" list seems quite useful to me for an
application updating an existing C system.

In the C system there is a simple structure array with the
first string being the key for lookup with linear search
(not a long list). The array is a global available to all
procedures and is initialized in a separate module as a
long data statement such as:

struct PROJ_ELLPS
proj_ellps[] = {
{"nameA", "field1", "field2", "field3"},
{"nameB", "field1", "field2", "field3"},
...
};

where "name?" is the lookup key. The initialization is
contained in a separate file.

This looks like a perfect application for C++ map container
but I cannot figure out how to do the equivalent
initialization. Every (*^% example I have of map applications
only shows a series of assignment statements in "main."

Is the equivalent usage and initialization possible?

If so, what does it look like?

Thanks for any help/suggestions.

[davidrubin]

Jerry Evenden wrote:

Just an old C programmer trying to learn a new trick
with C++ so excuse the dumb question:

The use of the "map" list seems quite useful to me for an
application updating an existing C system.

In the C system there is a simple structure array with the
first string being the key for lookup with linear search
(not a long list). The array is a global available to all
procedures and is initialized in a separate module as a
long data statement such as:

struct PROJ_ELLPS
proj_ellps[] = {
{"nameA", "field1", "field2", "field3"},
{"nameB", "field1", "field2", "field3"},
...
};

where "name?" is the lookup key. The initialization is
contained in a separate file.

This looks like a perfect application for C++ map container
but I cannot figure out how to do the equivalent
initialization. Every (*^% example I have of map applications
only shows a series of assignment statements in "main."

Is the equivalent usage and initialization possible?

You cannot construct a map from a series of discrete key/value pairs.
You can construct a map from another map (copy construction), or you
can construct an empty map, and fill it with a series of assignments
('insert', or 'operator[]' plus assignment).

[Alf P. Steinbach]

* Jerry Evenden:

[snip] struct PROJ_ELLPS
proj_ellps[] = {
{"nameA", "field1", "field2", "field3"},
{"nameB", "field1", "field2", "field3"},
...
};

where "name?" is the lookup key. The initialization is
contained in a separate file.

This looks like a perfect application for C++ map container
but I cannot figure out how to do the equivalent
initialization. Every (*^% example I have of map applications
only shows a series of assignment statements in "main."

Is the equivalent usage and initialization possible?

If so, what does it look like?

No such built-in thing.

In C++ you make such things, instead.

See <url: http://boost.org/libs/assign/doc/index.html#map_list_of>.

--
A: Because it messes up the order in which people normally read text.
Q: Why is it such a bad thing?
A: Top-posting.
Q: What is the most annoying thing on usenet and in e-mail?

[Jerry Evenden]

Alf P. Steinbach wrote:

* Jerry Evenden:

[snip]

struct PROJ_ELLPS
proj_ellps[] = {
{"nameA", "field1", "field2", "field3"},
{"nameB", "field1", "field2", "field3"},
...
};

where "name?" is the lookup key. The initialization is
contained in a separate file.

...
No such built-in thing.

In C++ you make such things, instead.

See <url: http://boost.org/libs/assign/doc/index.html#map_list_of>.

I think I see why. Unfortunately, the old fashion C method works
better in this case. I usually only do a lookup once for each
table and they are relatively short so a simple search is OK and a
make initialization would be a waste of time.

But I thought I had better check for sure. There may have been
some subtlety I missed.

Thanks all.

[Jim Langston]

"Jerry Evenden" <ge************@verizon.net> wrote in message
news:I0VEf.56$PK2.43@trndny06...

Alf P. Steinbach wrote:

* Jerry Evenden:

[snip]

struct PROJ_ELLPS
proj_ellps[] = {
{"nameA", "field1", "field2", "field3"},
{"nameB", "field1", "field2", "field3"},
...
};

where "name?" is the lookup key. The initialization is
contained in a separate file.

...

No such built-in thing.

In C++ you make such things, instead.

See <url: http://boost.org/libs/assign/doc/index.html#map_list_of>.

I think I see why. Unfortunately, the old fashion C method works
better in this case. I usually only do a lookup once for each
table and they are relatively short so a simple search is OK and a
make initialization would be a waste of time.

But I thought I had better check for sure. There may have been
some subtlety I missed.

Thanks all.

It wouldn't be difficult to initialize the map either in a function or a
class.

Perhaps you can simply wrap the map in a class and initialize it in the
constructor. You could also store the map pares in a data file and read the
data file to initialize the map. But, realistically, it's one statement
for:
MyMap[Mykey] = MyValue;
and one statement for:
MyCStruct =
{ MyKey, MyValue }

So what's the difference?

[Jay_Nabonne]

On Sat, 04 Feb 2006 02:30:34 +0000, Jerry Evenden wrote:

Just an old C programmer trying to learn a new trick
with C++ so excuse the dumb question:

The use of the "map" list seems quite useful to me for an
application updating an existing C system.

In the C system there is a simple structure array with the
first string being the key for lookup with linear search
(not a long list). The array is a global available to all
procedures and is initialized in a separate module as a
long data statement such as:

struct PROJ_ELLPS
proj_ellps[] = {
{"nameA", "field1", "field2", "field3"},
{"nameB", "field1", "field2", "field3"},
...
};

where "name?" is the lookup key. The initialization is
contained in a separate file.

This looks like a perfect application for C++ map container
but I cannot figure out how to do the equivalent
initialization. Every (*^% example I have of map applications
only shows a series of assignment statements in "main."

Is the equivalent usage and initialization possible?

If so, what does it look like?

Thanks for any help/suggestions.

How about this:

#include <iostream>
#include <map>
#include <string>

// Not needed; just to clarify below.
typedef std::string Key;
typedef std::string Data;

typedef std::pair<Key, Data> DataPair;
static DataPair mapData[] =
{
DataPair("nameA", "fieldsA"),
DataPair("nameB", "fieldsb"),
DataPair("namec", "fieldsc"),
};

// Create and initialize the map.
static std::map<Key, Data>
m(mapData, mapData+sizeof(mapData)/sizeof(mapData[0]));

int main()
{
std::cout << m["nameB"] << std::endl;
return 0;
}

If you want the "mapped to" part to be something besides a string, then
you can change it (but it needs to be constructable with data):

struct Fields
{
Fields() {} // needs this for to be in the map.
Fields(const char* fA, const char* fB, const char* fC)
: fieldA(fA), fieldB(fB), fieldC(fC)
{
}

const char* fieldA;
const char* fieldB;
const char* fieldC;
};

typedef Fields Data;

static DataPair mapData[] =
{
DataPair("nameA", Fields("fieldA1","fieldA2", fieldA3")),
// ...
};

//...
int main()
{
std::cout << m["nameA"].fieldB << std::endl;
return 0;
}

- Jay

[Clem.Dickey]

The basic technique in the parent is just what I use. One improvement,
IMO, is to declare a typedef for the map, and then use that type's
value_type (or a typedef thereof) as the type of the initialization
array. This change ties the initialization array element type
(DataPair, in the example) directly to the map type.

typedef std::map<Key, Data> M_map;
typedef M_map::value_type DataPair;