Question

lately I’ve been toying around with templates and stumbled upon the following problem. I am implementing the CRTP pattern like this:

template<typename derived_t>
struct protocol_object
{
    ...
};

struct data_object : public protocol_object<data_object>
{
    ...
};

I now would like to match instances of class protocol_object in a member template function, while still accepting non CRTP-types:

struct consumer_impl
{
    template<typename derived_t>
    void match(protocol_object<derived_t> &value)
    {
       std::cout << "protocol_class";
    };

    template<typename T>
    void match(T &value)
    {
       std::cout << "any other type";
    };
}

Unfortunately only the second version is ever called. Apparently match(protocol_object<derived_t> &value) is not considered or rejected in favour of the more general form match(T &value).

data_object object;
double value;
consumer_impl consumer;

consumer.match(value);  // yields "any other type" OK
consumer.match(object); // also yields "any other type" but want "protocol_class"

Is there a way out of this?

Thanks for any hints.
Arne

Answer 1

This isn’t related to CRTP. It’s a general case of the following:

• Design a template function, such that all derived classes use a particular specialization.

The issue is that T& value is an exact match for Derived&, while Base& is an inexact match. So we shall make the general form a worse match:

struct conversion_required { conversion_required(int) {} };

template<typename derived_t>
void match_impl(protocol_object<derived_t> &value, int)
{
   std::cout << "protocol_class";
};

template<typename T>
void match_impl(T &value, conversion_required)
{
   std::cout << "any other type";
};

template<typename T>
void match(T& value)
{
    return match_impl(value, 0);
}

Now the specialization, requiring an upcast, is a better match than the general template, requiring a user-defined conversion.