Using type passed as a template in C++

Question

Is it possible to actually use the type passed as a template for control flow? I'd like to write a function that uses templates, which in turn calls another function based on the type passed:

template <class T> void test_function (T var)
{
    //Do stuff
    if (T == char) {
        bar (var);
    } else {
        foo (var);
    }
    //Do even more stuff
}

If not, I'll have to fallback to enums...

Edit: All the answers up to now advise me to use template specialization. I wasn't very specific, but this is the same as not using templates at all because for every different type there's a single, different function call.

Answer 1

You can use template specialization for this. It means that you can define different implementations for generic void test_function(T) and specific void test_function(char)

Answer 2

It is possible to do this, but it is almost never a good idea to do it. A better idea is just to factor out the common bits and provide an overload for the function for those specific types, e.g.

template <class T> void test_function_prologue (T var)
{
    //Do stuff
}

template <class T> void test_function_epilogue (T var)
{
    //Do even more stuff
}

template <class T> void test_function (T var)
{
    test_function_prologue(var);
    foo (var);
    test_function_epilogue(var);
}

void test_function (char var)
{
    test_function_prologue(var);
    bar (var);
    test_function_epilogue(var);
}

Answer 3

You usually use specialization for that:

template<class T> void forward(T t) {
    // ...
}

template<> void forward<char>(char c) {
    // ...
}

template<class T> void test(T t) {
    forward<T>(t);
}

This gives you effectively "compile-time branching".

Answer 4

As long as foo() accepts an argument of type char and bar() accepts any T, it would be possible. Otherwise not. Both branches have to be compilable for any T you instantiate the template with, even if one branch is never taken. If both branches are not compilable for any T, you have no option than to use compile-time branching (which is preferable in any case).

Otherwise you might use Runtime Type Identification:

if (typeid(T) == typeid(char))

or a compile-time check:

if (boost::is_same<T, char>::value)

where is_same might be implemented as

template <class T, class U>
struct is_same { static const bool value = false; };

template <class T>
struct is_same<T, T> { static const bool value = true; };

Answer 5

Even with your edited response, I'll still suggest template specialization. You just make a proxy function that calls the function you want:

template <class T> void call_other_function(T var)
{
   foo(var);
}

template <> void call_other_function<char>(char var)
{
   bar(var);
}

template <class T> void test_function (T var)
{
    //Do stuff
    call_other_function(var);
    //Do even more stuff
}