Triple map including 2 keys - c++

Question

I have a structure containing 3 fields, two ints (let's call them A and B) and a bool (C).
I want to create a sort of array of that struct and be able to access it through any of the keys (A or B), getting the hole object (with A, B and C) in return.
I won't need to do something like "getting all the object for which the bool is true", if that makes any difference.
Obviously, both key are unique and the bool can't be, but I thought I'd mention it for the sake of clarity.
If there was no A or B, it would be a simple std::map<int, bool>.
The only solution I currently see is to make a wrapper containing 2 sets and a vector.
Is there any way to make my life easier?
NB: It will contain at most a hundred tuples, so performance should not be an issue. Linear access is acceptable.
To make it even clearer, here is what I'd like to be able to do:
foobar<int, int, bool> array; // or something along those lines
array.add(1, 101, true);
array.add(2, 102, false);
array.getA(1); // returns first object
array.getA(2); // returns second object
array.getB(102); // returns second object again

Answer 1

I believe what you're looking for is boost::multi_index. It'll allow you to declare a container with multiple indices.
struct MultiIDStruct
{
size_t idA;
size_t idB;
std::string name;
};
namespace mul = boost::multi_index;
boost::multi_index_container< MultiIDStruct,
mul::indexed_by<
mul::ordered_unique< mul::member< MultiIDStruct, size_t, &MultiIDStruct::idA > >,
mul::ordered_unique< mul::member< MultiIDStruct, size_t, &MultiIDStruct::idB > >
> > data;
(Used namespace "shortcut" as per Rapptz suggestion)
For example here you have a multi_index container of MultiIDStruct for which there are two unique orderings, one on idA (which is a member of MultiIDStruct) and a second on idB (which is also a member).
The template parameters seem like a handful at first but they're not so bad once you understand how they work.

Answer 2

The suggestion to split it up into two maps is certainly a bit simpler, but if you want some more flexibility and can use C++11 for features like std::tuple, you might try something of the form:
#include <iostream>
#include <map>
#include <tuple>
template <typename T1, typename T2, typename T3>
class foobar
{
public:
void add(T1 t1, T2 t2, T3 t3)
{
m1[t1] = std::make_tuple(t1, t2, t3);
m2[t2] = std::make_tuple(t1, t2, t3);
}
std::tuple<T1,T2,T3> getA(T1 t1)
{
return m1[t1];
}
std::tuple<T1,T2,T3> getB(T2 t2)
{
return m2[t2];
}
private:
std::map<T1,std::tuple<T1,T2,T3>> m1;
std::map<T2,std::tuple<T1,T2,T3>> m2;
};
int main()
{
foobar<int, int, bool> array; // or something along those lines
array.add(1, 101, true);
array.add(2, 102, false);
auto res1 = array.getA(1); // returns first object
auto res2 = array.getA(2); // returns second object
auto res3 = array.getB(102); // returns second object again
std::cout << std::get<0>(res1) << std::endl;
std::cout << std::get<1>(res2) << std::endl;
std::cout << std::get<2>(res3) << std::endl;
return 0;
}
A working example gives the output 1, 102, 0 (false).

Answer 3

I know I didn't give the detail implementation. But I'm just suggesting a logic with two maps. What's wrong with it? Why do I get downvoted?
struct s
{
int i;
int j;
bool b;
};
std::map<int, int> mapA;
std::map<int, s> mapB;
const s& getA(int i)
{
return mapB[mapA[i]];
}
const s& getB(int j)
{
return mapB[j];
}
void add(int i, int j, bool b)
{
s p;
p.i=i;
p.j=j;
p.b=b;
mapB[j]=p;
mapA[i]=j;
}

Answer 4

Having the same problem, and a different solution!
Have two hash functions on A and B, giving h1(A) and h2(B) such, that they do not give equal values. Example:
uint32_t A;
uint32_t B;
uint64_t hashA(uint32_t value)
{ return ((uint64_t)value) << 32; }
uint64_t hashB(uint32_t value)
{ return (uint64_t)value; }
Put all your stuff into std::map so that hashA and hashB have the same value for bool. Access it with either hashA or hashB.
Example: A = 0x10000001, B = 0x20000002, C = true
hashA(A): 0x1000000100000000
hashB(B): 0x0000000020000002
map:
0x1000000100000000 -> true
0x0000000020000002 -> true