CODEWITHSUNDEEP
c++templatestemplate-specializationmember-variables
tjwrona
tjwrona

Reputation: 9035

How do member variables work with specialized class templates?

I'm trying to write a very simple specialized class template that has a member variable and can print that member variable differently in specialized situations. I know the example is pretty useless, but it illustrates the question pretty well.

When specializing class templates it seems that the specializations of the class don't share the same member variables, so the following code won't compile...

#include <iostream>
#include <string>

// Class template
template <typename T>
struct S
{
    S(const T& t)
        : t(t)
    {}

    void print()
    {
        std::cout << t << std::endl;
    }
private:
    T t;
};

// Specialization
template <>
struct S<std::string>
{
    void print()
    {
        // ERROR: "t" is not defined in this context
        std::cout << "string: " << t << std::endl;
    }
};

This suggests that I would need to write a separate constructor for every specialization and have a separate member variable t for each specialization which feels like it would quickly become a lot of duplicated code and effort if I have many specializations.

If what I am saying is true, then is it bad practice to use member variables in specialized class templates altogether? Are there any alternatives that result in less code duplication?

Upvotes: 2

Views: 1004

Answers (4)

Eyal
Eyal

Reputation: 5848

Another way to do it is to use a helper function. This will let you do partial template specialization kind of, working around the issue noted by @0x499602D2. What we're doing is having the templated function call a helper function and the helper function is doing all the specialization.

I added another template parameter into there to show that this solution kind of works for partial template specialization. Notice that the templated helper function is full-specialized, not partially. You can't partially specialize a function. This can be useful in cases when the class template has more template parameters that you can't specialize (UNUSED_T) but the function that you do want to specialize can be fully specialized (print_it doesn't need the UNUSED_T).

#include <iostream>
#include <string>

// This is the helper function for all types T...
template <typename T>
void print_it(T t) {
    std::cout << t << std::endl;
}

// ... except for std::string, it will run this one.
template <>
void print_it<std::string>(std::string t) {
    std::cout << "string: " << t << std::endl;
}

// Class template, UNUSED is there just to show that
// this works for partial template specialization.
template <typename T, typename UNUSED_T>
struct S {
    S(const T& t) : t(t) {}

    void print() {
        // You can remove the <T> because
        // the compiler will figure it out for you.
        print_it<T>(t);
    }
prviate:
    T t;
    UNUSED_T unused;
};

int main() {
    S<uint, char> x(5);
    x.print(); // OUTPUT: 5
    S<std::string, char> y("foo");
    y.print(); // OUTPUT: string: foo
}

Upvotes: 1

n314159
n314159

Reputation: 5095

Please also look at @0x499602D2's answer, it is simpler and works for many practical cases.

You are correct, the specializations are basically totally independet from each other and the original template, so you would have to write everything new. A way to get around that would be to use inheritance.

#include <iostream>
#include <string>

// Class template
template <typename T>
struct Base
{
    Base(const T& t)
        : t(t)
    {}

    virtual void print()
    {
        std::cout << t << std::endl;
    }

protected:
    T t;
};

template<class T>
struct S: Base<T> {
};

// Specialization
template <>
struct S<std::string>: Base<std::string>
{
    void print() override
    {
        std::cout << "string: " << t << std::endl;
    }
};

Upvotes: 7

max66
max66

Reputation: 66240

Another possible solution is tag-dispatcing

template <typename T>
struct S
 {
   private:
      T t;

      void print_helper (std::true_type) // T is std::string
       { std::cout << "string: " << t << std::endl; }

      void print_helper (std::false_type) // T isn't std::string
       { std::cout << t << std::endl; }

   public:
      S (T const & t0) : t{t0}
       { } 

      void print ()
       { print_helper(std::is_same<T, std::string>{}); }
 };

Upvotes: 2

David G
David G

Reputation: 96845

Since you are only specializing a single template parameter, you can explicitly specialize the member function instead of the entire class:

template <>
void S<std::string>::print()
{
    std::cout << "string: " << t << std::endl;
}

Upvotes: 2

Related Questions