0

I wrote a simple program to convert Roman numbers to Japanese (roomaji).
This program needs to lookup a string using a number (think std::map).
And I'm wondering about the pros/cons of the 3 methods I thought about:
Method 1
I guess the major con here is you need to initialize the data at runtime, keep track of the initialization state, etc.

typedef std::multimap<unsigned long, std::string> UnitMap;
UnitMap Units;
static bool UnitsInitialized = false;
void InitializeUnits()
{
    if (!UnitsInitialized)
    {
        UnitsInitialized = true;
        boost::assign::insert(Units)
            (0, "zero")
            (0, "rei")
            //...
    }
}

Method 2
This is very C to me.

struct Unit
{
    unsigned long Value;
    const std::string Roomaji;
};
const Unit Units[] = 
{
    {0, "zero"},
    {0, "rei"}
    //...
};

Method 3
This is just like the previous method except a std::pair is used.
I'm thinking the std::pair constructor is called for every unit here which is less than optimal.
This 'feels' more C++ to me though.

typedef std::pair<unsigned long, std::string> Unit;
const Unit Units[] =
{
    Unit(0, "zero"),
    Unit(0, "rei")
    //...
};

Are there any other methods (without an external source)?
And what are the pros/cons here?

2
Contributors
5
Replies
6
Views
8 Years
Discussion Span
Last Post by dewyatt
0

Edit limit got me.

I wanted to add:
-The table will actually only have about 20 items.

0

I don't understand why you consider these three methods equally matched. The 1st method only builds the desired multimap.

I think the std::multimap native interface is not suitable for most of applications (too cumbersome and unclear), so you need your own problem-oriented multimap wrapper class. You may initialize static multimap member in its constructor from method #2 or #3 sources (placed in the wrapper implementation module). Use boolean "initialized" static member to avoid redundant multimap initialization in possible consequent wrapper constructor calls.

0

The first method inclues the code to build the map because it is required. There's no way to build the map at compile-time that I know of.
The other methods have an advantage in that the data is 'built' at compile-time and needs no explicit initialization at runtime.

I'm thinking multimap is a little too heavy for this since I'll only have around 20 items. But I'm not really sure.

Right now I'm thinking of going with Method 2 (or possibly 1).

0

In actual fact all three methods construct data in run time because it's impossible to create std::string (and especially std::multimap) in compile time: the C++ compiler know nothing about generic data structures internal representation!

>I'm thinking the std::pair constructor is called for every unit here which is less than optimal
It's of no importance (and not only for std::pair constructor): it's startup flash code only...

I'm not sure that this mini-multimap is a proper data structure at all. But if you have the strong specification (of multimap using) then it seems the best method is to declare multimap<unsigned,const char*> and incapsulate it in a simple wrapper class then initialize it in the class constructor from type#2 data structure...

0

In actual fact all three methods construct data in run time because it's impossible to create std::string (and especially std::multimap) in compile time: the C++ compiler know nothing about generic data structures internal representation!

Ah! I originally had const char* 's, not std::string 's. But I changed it at some point.

I'm not sure that this mini-multimap is a proper data structure at all. But if you have the strong specification (of multimap using) then it seems the best method is to declare multimap<unsigned,const char*> and incapsulate it in a simple wrapper class then initialize it in the class constructor from type#2 data structure...

I think this is pretty much what I will do. Thanks for your help.

This topic has been dead for over six months. Start a new discussion instead.
Have something to contribute to this discussion? Please be thoughtful, detailed and courteous, and be sure to adhere to our posting rules.