how can I map an int to a corresponding string in C/C++

Question

I have 20 digits that I would like to associate with strings. Is there a faster way besides using a switch case I can do this with. Basically I need to convert an int to a correponding string and the numberes arent necessarily packed. Maybe there is something in Qt as well?

for example 1 would be used to get "Request System Info" 2: "Change System Info" 10: "Unkown Error"

Answer 1

std::map

---

Reading through your question again, I think you're saying that you have only 20 numbers to map (you said 20 digits, which made me think of very large numbers). If these are all in a fairly small range, you might be better off just using an array. You need an array of string pointers as large as largestIndex - smallestIndex + 1. Then to get the string associated with a certain number, you'd do something like:

std::string GetStatus(int statusID){
    return statusArray[statusID - smallestIndex];
}

The statusArray variable is initialized with something like:

void SetStatus(int statusID, std::string description){
    statusArray[statusID - smallestIndex] = description;
}

void InitStatuses(){
    statusArray = new std::string[largestIndex - smallestIndex + 1];
    SetStatus(1, "Request System Info");
    SetStatus(2, "Change System Info");
    SetStatus(10, "Unknown Error");
}

This would be faster than a map, and pretty easy to use. It's just not appropriate if your IDs vary widely.

Answer 2

I recommend std::map<>

#include <map>
#include <string>

std::map<int, std::string> mapping;

// Initialize the map
mapping.insert(std::make_pair(1, "Request System Info"));
mapping.insert(std::make_pair(2, "Change System Info"));
mapping.insert(std::make_pair(10, "Unkown Error"));

// Use the map
std::map<int, std::string>::const_iterator iter =
    mapping.find(num);
if (iter != mapping.end())
{
    // iter->second contains your string
    // iter->first contains the number you just looked up
}

If you have a compiler that implements the initalizer-list feature of the draft C++0x standard, you combine your definition and initialization of the map:

std::map<int, std::string> mapping = {{1, "Request System Info"},
                                      {2, "Change System Info"}
                                      {10, "Unkown Error"}};

std::map<> scales well to a large number of entries as std::map<>::find runs in O(log N). Once you have the hash-map feature of the draft C++0x standard, you can easily convert this to a std::unordered_map<> which should be able to look things up in O(1) time.

Answer 3

Something like: ?

#include <sstream>
using namespace std;
string f(int i)
{
    ostringstream oss;
    oss << i;
    return oss.str();
}

Answer 4

If you are looking for speed, the switch statement will be the most efficient. Most C/C++ compilers will implement it as a binary tree, so it is really fast.

Answer 5

Qt also provides it's own map implementations - QMap and QHash.

QMap<int, QString> myMap;
myMap[1234] = "Some value";
myMap[5678] = "Another value";

or

myMap.insert(1234, "Some value");

The documentation gives more examples but it's very easy to use.

Answer 6

If your numbers and strings are constant, a map will not work; it has has to be loaded.

For constant numbers and strings, I recommend an array of:

struct Entry
{
   unsigned int  key;
   const char *  text;
};

And for a large quantity, use a binary search algorithm; otherwise a linear search is about as fast (as long as the array is sorted).

Answer 7

easier way to use map

std::map<int, std::string> mymap
mymap[1] = "foo";
mymap[10] = "bar;
....
std::string lookup = mymap[idx];

Answer 8

Are the strings known at compile time? If so create a map

std::map messages;

messages[key] = "some value"; messages[key2] = "some other value";

etc

If they're to be read from a file then something like this

std::ifstream ifile("the file")

while (ifile && !ifile.eof())
{
  ifile >> key >> value;
  messages[key] = value;
}

etc

Answer 9

If your numbers are contiguous (or nearly so), a simple array or vector of strings will work quite nicely.

If there are large gaps between the numbers, chances are that the fastest method will be an array of std::pair<int, std::string> (or std::pair<int, char *>). While most people automatically think of a binary search for fast lookups, in this case the small number of possibilities to be considered may well allow a linear search to compete quite effectively -- in fact, it may well be the fastest choice available. The reason is simple: while it'll do more comparisons, it avoids things like divisions, and comparisons on 20 ints is going to be fast anyway.

Edit: note that std::map probably is not a really good choice. std::map normally uses a balanced binary tree, which means 20 items will use 20 nodes, each of which is normally allocated separately. Each node will typically include at least two pointers in addition to the int you need to store, so you're roughly tripling the amount of data you're storing -- that all adds up to relatively poor cache locality. Given the small number of items involved, one cache miss will cost more than 20 comparisons.

Answer 10

If your strings are known at compile-time, then you can do this in C:

#include <stdio.h>

struct message {
    int val;
    const char *msg;
};

int main(void)
{
    struct message messages[] = {
        {1, "Request System Info"},
        {2, "Change System Info"},
        {10, "Unkown Error"}
    };
    size_t nmessages = sizeof messages / sizeof messages[0];
    size_t i;

    for (i=0; i < nmessages; ++i) {
        printf("%d : '%s'\n", messages[i].val, messages[i].msg);
    }
    return 0;
}