A sample usage of traits template technique to do type-agnostic comparison.

opload.cc

#include <iostream>


class C
{
public:
    C(const int i) :
        _i(i)
    {
    }

    int Get() const
    {
        return _i;
    }

private:
    const int _i;
};

static inline bool operator== (const C& lhs, const C& rhs)
{
    return lhs.Get() == rhs.Get();
}


template <typename cT>
struct class_traits { };

template<>
struct class_traits<C>
{
    typedef C class_type;
    static inline bool Eq (const class_type &lhs, const class_type &rhs)
    {
        return lhs.Get() == rhs.Get();
    }
};


template <typename cT>
class Container
{
public:

    typedef cT class_type;
    typedef class_traits<class_type> traits_type;

    Container(const class_type& rc) :
        _rc(rc)
    {
    }

    bool Eq(const class_type& other) const
    {
        traits_type::Eq(_rc, other);
    }

private:
    const class_type& _rc;
};


typedef Container<C> CContainer;


int main()
{
    C c1(42);
    C c2(42);
    std::cout << std::boolalpha << "c1 == c2 ? " << (c1 == c2) << std::endl;

    CContainer cc(c1);
    std::cout << std::boolalpha << "cc.Eq(c2) ? " << cc.Eq(c2) << std::endl;

    return 0;
}