How to aggregate values in C++ using keys? - c++

Question

In C++ how can I aggregate values for a struct based on three keys?
In Perl I would do this using a hash of hashes (e.g. something like $hash{$key1}{$key2}{$key3}{'call_duration'} += 25);
As I'm a complete newbie to C++ could you please suggest a suitable approach?
I've had a look at topics on SO discussing nested hash equivalents in C++ using std::map, however it states that this is slow performance-wise and as I need to process records for a telecom operator, performance is critical.
It's not necessary that I follow an approach that uses the template library or anything that should resemble Perl in syntax and mindset, but if you have had to do something similar, could you please share a fast and suitable way to implement it?
I'm mostly limited to the C++ 98 standard (the technical lead has allowed the use of newer features provided that they are supported by the compiler and they are of critical benefit).
Apologies if the description is muddled and thanks in advance!
edit: The compiler version is GCC 4.1.2, importing tr1/functional as a library isn't frowned upon by it.
edit: Thanks very much to everyone that joined, in particular to Bartek and Rost for putting up with my stupid questions. I decided to choose Rost's answer as it's what I was actually able to get to work! :)

Answer 1

Common std::map shall be suitable, its performance is usually not a problem for most cases. Hash provides constant time access to elements, tree-based map provides logarithmic time, but in reality constant time maybe greater than logarithmic - it depends on specific implementation and specific data. In case when you fill container once and then only update data without key changing/inserting/deleting you could use sorted std::vector or Loki::AssocVector.
You shall first try std::map (or std::set if the key is actully part of data) and only then make decision is it too slow for you or not. Example:
// Composite key definition
struct CompositeKey
{
int key1;
std::string key2;
AnotherType key3;
CompositeKey(int i_key1, const std::string& i_key2, AnotherType i_key3):
key1(i_key1), key2(i_key2), key3(i_key3)
{}
bool operator < (const CompositeKey& i_rhs) const
{
// You must define your own less operator for ordering keys
}
};
// Usage
std::map<CompositeKey, Data> aggrData;
aggrData[CompositeKey(0, "KeyString", AnotherType())] = Data();
if(aggrData.find(CompositeKey(0, "KeyString", AnotherType())) != aggrData.end())
{
// Process found data
}
For further performance research you could try:
hash_map/hash_set (named stdex::hash_map in MSVC++ and __gnu_cxx::hash_map in GCC)
boost::unordered_map/boost::unordered_set
Loki::AssocVector
std::unordered_map/std::unordered_set - for C++11 only
All these containers have similar interface so it will not be difficult to encapsulate it and easily switch implementation if required.

Answer 2

The simple solution is to use struct aggregating the 3 keys, and use it as key.
struct Key
{
Type1 Key1;
Type2 Key2;
Type3 Key3;
// I forgot about the comparator - you have to provide it explicitly
};
Because you are somewhat limited with language, check if your compiler supports std::hash_map:
std::hash_map<Key, TValue> Data;
If not, you could always use boost::unordered_map.
If someone else stumbles on the same problem, the "proper solution", however, is this:
std::unordered_map<std::tuple<Type1, Type2, Type3>, TValue>;
EDIT: Sample usage
struct Key
{
int Int;
float Float;
string String;
// add ctor and operator<
};
std::hash_map<Key, int> Data;
Data[Key(5, 3.5f, "x")] = 10;