Question

I want to create a calculator

template < typename T >
class Calculator
{
    public :
    Calculator ( void );
    ~Calculator ( void );

    T add(T a, T b)
    {
       return ( a + b ) ;
    }
};

Now I want to make this Caculator add strings, so add(“Tim”,”Joe”) shall give me “TimJoe” .

Can I use template function specialization for achieving this by making necessary changes to the existing class .

Answer 1

Why would you want to ?

Calculator<std::string> a;
std::cout << a.add("Hello", " world") << std::endl;

This code outputs “Hello world”. It’s not optimal (std::string parameters in the add member function are taken by value), but it does not require a specialization to work.

EDIT OK, you want specialization, but you can’t just specialize the add member function because the function is not template itself. You can either specialize the whole class :

template<>
class Calculator<std::string>
{
public :
    Calculator() {}
    ~Calculator() {}

    std::string add(const std::string &a, const std::string &b)
    {
        // Do std::string specific stuff
        return a + b ;
    }
};

Or make the add member function template and specialize it :

class Calculator
{
public :
    Calculator () {}
    ~Calculator () {}

    template<class T>
    T add(T a, T b)
    {
       return a + b;
    }
};

template<>
std::string Calculator::add<std::string>(std::string a, std::string b)
{
    // Do std::string specific stuff
    return a + b ;
}

With the second solution, a single Calculator instance will then be able to add int, std::string or whatever you need (as it’s the add function which is template, not the Calculator class itself).