Creating map entry using a user-defined conversion - c++

Question

I'm got a map of key type std::pair<Foo,Bar> and value in which I would like to insert into a map by passing the pair std::pair<std::pair<Foo,Bar> , int> to the insert function like so (online source)
struct Foo{};
struct Bar{};
typedef std::pair<Foo,Bar> FooBar;
typedef std::pair<FooBar,int> FooBarPair;
typedef std::map<FooBar,int> FooBarMap;
struct FooBarData
{
operator const FooBarPair() const
{
return std::make_pair( std::make_pair( m_foo , m_bar ) , m_num );
}
private:
int m_num;
Foo m_foo;
Bar m_bar;
};
int main()
{
FooBarData fbd;
FooBarMap fbm;
fbm.insert( fbd );
}
clang error message
/usr/include/c++/v1/map:1041:9: note: candidate function not viable: no known conversion from 'FooBarData' to 'const value_type' (aka 'const pair<const key_type, mapped_type>') for 1st argument
insert(const value_type& __v) {return __tree_.__insert_unique(__v);}
^
/usr/include/c++/v1/map:1050:14: note: candidate function template not viable: requires 2 arguments, but 1 was provided
void insert(_InputIterator __f, _InputIterator __l)
^
/usr/include/c++/v1/map:1045:9: note: candidate function not viable: requires 2 arguments, but 1 was provided
insert(const_iterator __p, const value_type& __v)
Is there any fix along these lines?

Answer 1

Add missing operator <.
Also, remove const from return type of conversion operator.
Edit After your change in Q:
You have to change your conversion to
operator std::pair<const FooBar, int>() const
Else, it would require 2 user conversions, which is not allowed.
Demo

Answer 2

(At least sometimes), the map implementations are/were red black trees. For map insert to work, your key type needs to support comparison (operator <). I cannot see this requirement to be met for your empty structs and the pair you create from them.
So as a first sanity check, I would replace Foo and Bar structs with
typedef int Foo;
typedef int Bar;
in order to see if something else is wrong with your code.
If it still is not compiling, check if std::pair<> supports comparison.
Also, instead of typedef'ing the FooBarPair yourself, you can simply enjoy that the map template already did that for you. For example:
...
operator FooBarMap::value_type() {
...
}
Here a fixed version, which compiles:
#include <map>
struct Foo { int x; };
struct Bar {};
typedef std::pair<Foo, Bar> FooBar;
typedef std::map<FooBar, int> FooBarMap;
bool operator <(const FooBarMap::key_type&lhs, const FooBarMap::key_type& rhs)
{
return lhs.first.x < rhs.first.x;
}
struct FooBarData
{
operator FooBarMap::value_type() const
{
return FooBarMap::value_type(FooBarMap::key_type(m_foo, m_bar), m_num);
}
private:
int m_num;
Foo m_foo;
Bar m_bar;
};
int main()
{
FooBarData fbd;
FooBarMap fbm;
fbm.insert(fbd);
}