Question

I have some problems overloading operators with template members and using make_pair:

class MyArchive
{
    public:
    template <class C> MyArchive & operator<< (C & c)
    {

        return (*this);
    }
};

class A
{

};

int main()
{

    MyArchive oa;
    A a;
    oa << a; //it works
    oa << std::make_pair(std::string("lalala"),a); //it doesn't work
    return 0;
}

I get this interesting error:

/home/carles/tmp/provaserialization/main.cpp: In function ‘int main()’:
/home/carles/tmp/provaserialization/main.cpp:30: error: no match for ‘operator<<’ in ‘oa << std::make_pair(_T1, _T2) [with _T1 = std::basic_string<char, std::char_traits<char>, std::allocator<char> >, _T2 = A]((a, A()))’
/home/carles/tmp/provaserialization/main.cpp:11: note: candidates are: MyArchive& MyArchive::operator<<(C&) [with C = std::pair<std::basic_string<char, std::char_traits<char>, std::allocator<char> >, A>]

Any ideas about why it doesn’t find operator<< in the second case?

Answer 1

The parameter of operator<< should be const :

template <class C> MyArchive & operator<< (const C & c)

Because std::make_pair returns a temporary object which cannot be bound to non-const parameter. But a temporary object can be bound to a const parameter, since then the life of the temporary extends, till the end of the called function.

---

A simple demonstration:

template<typename T>
void f(T & c) { cout << " non-const parameter" << endl; }

template<typename T>
void f(const T & a) { cout << "const parameter" << endl; }

int main() 
{
     f(make_pair(10,20.0)); //this calls second function!
}

Output:

const parameter

See the output yourself here: http://www.ideone.com/16DpT

EDIT:

Of course, the above output explains only that temporary is bound to the function with const-parameter. It doesn’t demonstrate life-extension. The following code demonstrates life-extension:

struct A 
{
  A() { cout << "A is constructed" << endl; }
  ~A() { cout << "A is destructed" << endl; }
};

template<typename T>
void f(T & c) { cout << " non-const parameter" << endl; }

template<typename T>
void f(const T & a) { cout << "const parameter" << endl; }

int main() 
{
     f(A()); //passing temporary object!
}

Output:

A is constructed
const parameter
A is destructed

The fact that A is destructed after the function prints const parameter demonstrates that A’s life is extended till the end of the called function!

Code at ideone : http://www.ideone.com/2ixA6