CODEWITHSUNDEEP
c++c++11
philipp
philipp

Reputation: 1823

how to call a function in C++11 templates only when its defined

Looking at a simple template scenario like this:

class A {
    public:
        int work();
};

class B {
    public:
        int work();
};

class ObjectManager {
    public:
        static void manage( A& obj );
        // manage not defined for class B 
};

template<class T>
doStuff( T t ) {
    t.work();
    ....
    ObjectManager::manage(t);
};


A a;
B b;

doStuf(a);
doStuff(b);

I am wondering, what is the cleanest way to implement a conditional call to ObjectManager::manage? The template function should determine in compile-time if ObjectManager::manage(T t) is defined for the given T and activate some lines of code only when it is. I guess there are solutions with some more nested template calls, but it would be the best for me just to keep the function in one piece.

Upvotes: 2

Views: 152

Answers (1)

T.C.
T.C.

Reputation: 137425

Note that currently your class members are all private. They should be made public.

template<class T>
auto call_manage(T* t) -> decltype(ObjectManager::manage(*t)){
    return ObjectManager::manage(*t);
}

void call_manage(...) {}

template<class T>
void doStuff( T t ) {
    t.work();
    //....
    call_manage(std::addressof(t)); // smack whoever overloaded unary 
                                    // operator & in the head first
}

If the expression ObjectManager::manage(*t) is well-formed, substitution succeeds for the function template, which is always a better match than ..., so it is called. Otherwise, the do-nothing overload is the only viable function.

Demo.

For those who like references:

template<class T>
auto call_manage(T& t) -> decltype(ObjectManager::manage(t)){
    return ObjectManager::manage(t);
}

template<class... T>
void call_manage(T&&...) {}

template<class T>
void doStuff( T t ) {
    t.work();
    //....
    call_manage(t);
}

In this case, the single-argument overload is more specialized than the variadic version by the partial ordering rules for function templates, and is selected by overload resolution if both are equally viable. You can also make it take T&& t and call manage(std::forward<T>(t)), for perfect forwarding.

Demo.

Upvotes: 5

Related Questions