Creating map entry using a user-defined conversion

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);
}