Is it possible to write specialization for member function of a template class?

template <class T, bool flag>
class A
{
    //...
    void f()
    {
        std::cout << "false" << std::endl;
    }
    //...
};

template<class T>
void A<T, true>::f<T, true>()
{
    std::cout << "true" << std::endl;
}

The code above is wrong and don't compile, but you get开发者_运维知识库 the idea of what I'm going to do. So how should I do that?

You can't specialize just one method of a class. Usually you can solve that with a template nested class on the same T.

template <class T, bool flag>
class A
{
    //...
    template <class Q, bool flag>
    class F_Helper
    {
        void operator()()
        {
            std::cout << "false" << std::endl;
        }
    };

    template <class Q>
    class F_Helper<Q, true>
    {
        void operator()()
        {
            std::cout << "true" << std::endl;
        }
    };

    F_Helper<T> f;
    //...
};

Obviously a bit more boilerplate is needed if you do need access to the enclosing class' this pointer.

Contrary to what the other answers say, you can specialize a member function of a class template. But you need to provide all template arguments

template<>
void A<int, true>::f()
{
    std::cout << "true" << std::endl;
}

What you try is not valid:

template<typename T>
void A<T, true>::f()
{
    std::cout << "true" << std::endl;
}

Partially specializing a member of a class template for particular arguments of that class template is not valid, so that means "define the member function 'f' of a partial specialization of A for <T, true>". Because there is no such partial specialization, the compiler will error out.

If you cannot provide all arguments, you can overload f as follows

template <class T, bool flag>
class A
{
    template<typename, bool> struct params { };

    void f()
    {
        f(params<T, flags>());
    }

    template<typename U>
    void f(params<U, true>) {
        std::cout << "true" << std::endl;
    }

    template<typename U, bool flag1>
    void f(params<U, flag1>) {
        std::cout << "dunno" << std::endl;
    }
};

You can specialize whole template class - Ideone link

#include <iostream>

template <class T, bool flag>
class A
{
    //...
    void f()
    {
        std::cout << "false" << std::endl;
    }
    //...
};

template<class T>
class A<T, true>
{
    //...
    void f()
    {
        std::cout << "true" << std::endl;
    }
    //...
};

You need to specialize the whole class:

#include <iostream>

template <class T, bool flag>
class A
{
public:
    void f()
    {
        std::cout << "false" << std::endl;
    }
};

template<class T>
class A<T,true>
{
public:
    void f()
    {
        std::cout << "true" << std::endl;
    }
};

void main()
{
    A<int, false> a;
    a.f();

    A<int, true> b;
    b.f();
}