Storing and accessing a collection of strings (STD C++)

SKU1       SKU2        Description
"01234"    "34545"     "White Bread"
"01545"    "34236"     "Wheat Bread"

I need to cross-reference these three fields, i开发者_开发技巧.e. retrieve SKU2 while knowing SKU1, SKU1 while knowing SKU2, and Description while knowing either SKU1 or SKU2.

I'm curious - what is the best way to do this? Vectors using search() or find()? Using a map somehow?

I currently have it working using a vector< vector<string> >, looping through the 'parent' vectors and the 'child' vectors, comparing the values, but this seems primitive.

Basically, I need a vector that uses any of its strings as an index to return one of the two other values. Is the general way I'm doing it considered acceptable/optimal?

vector< vector<string> > products;

int i = 0;
for( i = 0; i < 2; ++i)
{
    products.push_back( vector<string>() );

    products[i].push_back( "SKU1" );
    products[i].push_back( "SKU2" );
    products[i].push_back( "Description" );

}

Thanks for your assistance.

Boost BiMap.

I would recommend using two maps that index into an object that has the information you need:

struct MyInfo
{
  std::string SKU1;
  std::string SKU2;
  std::string Description;
};

std::map<std::string, MyInfo *> SKU1map;
std::map<std::string, MyInfo *> SKU2map;

MyInfo * newProduct = new MyInfo; ///Do not forget to delete!!
newProduct->SKU1 = //SKU1 value
newProduct->SKU2 = //SKU2 value
newProduct->Description = //Description value

SKU1map[newProduct->SKU1] = newProduct;
SKU2map[newProduct->SKU2] = newProduct;

This will be a decently fast implementation(much better than linear search), and if you deal with many product instances, then it will also be more memory efficient.

Build three std::map<std::string, std::string>s: one to map SKU1s to SKU2s, one to map SKU1s to Descriptions, and one to map SKU2s to Descriptions. (Better yet, use std::unordered_map, if you have it (C++0x)).

This is assuming that you have a lot of data and are prioritizing speed rather than memory usage.