How to do it...

In this recipe, we'll implement a little helper template class. It can deal with different template type specializations because it is able to select completely different code in some passages, depending on what type we specialize it for:

1. Write the part of the code that is generic. In our example, it is a simple class, which supports adding a type U value to the type T member value using an add function:

       template <typename T>
       class addable
       { 
           T val;
        
       public:
           addable(T v) : val{v} {}
        
           template <typename U>
           T add(U x) const {
               return val + x;
           }
       };

1. Imagine that type T is std::vector<something> and type U is just int. What shall it mean to add an integer to a whole vector? Let's say it means that we add the integer to every item in the vector. This will be done in a loop:

       template <typename U>
       T add(U x) 
       {
           auto copy (val); // Get a copy of the vector member
 for (auto &n : copy) { 
 n += x;
 }
 return copy;
 }

1. The next and last step is to combine both worlds. If T is a vector of U items, do the loop variant. If it is not, just implement the normal addition:

 template <typename U>
 T add(U x) const {
 if constexpr (std::is_same_v<T, std::vector<U>>) {
 auto copy (val);
 for (auto &n : copy) { 
 n += x;
 }
 return copy;
 } else {
 return val + x;
 }
 }

1. The class can now be put to use. Let's see how nicely it works with completely different types, such as int, float, std::vector<int>, and std::vector<string>:

 addable<int>{1}.add(2); // is 3
 addable<float>{1.0}.add(2); // is 3.0
 addable<std::string>{"aa"}.add("bb"); // is "aabb"

 std::vector<int> v {1, 2, 3};
 addable<std::vector<int>>{v}.add(10); 
 // is std::vector<int>{11, 12, 13}

 std::vector<std::string> sv {"a", "b", "c"};
 addable<std::vector<std::string>>{sv}.add(std::string{"z"}); 
 // is {"az", "bz", "cz"}