只有一个参数的模板特化

Question

If you have a class template such as this:

    template <typename T, unsigned CAPACITY>
    class Collection
    {
        T m_array[CAPACITY]{};
        T m_dummy{};
        unsigned m_size{};
    }
    public:
        void display(std::ostream& ostr = std::cout) const 
        {
            ostr << "----------------------" << std::endl;
            ostr << "| Collection Content |" << std::endl;
            ostr << "----------------------" << std::endl;
        }

And I wanted to create specialization depending on the type used, but not the CAPACITY, is this possible?

I have this, which works:

    void Collection<Pair, 50u>::display(std::ostream& ostr) const
    {
        ostr << "----------------------" << std::endl;
        ostr << "| This is a Pair |" << std::endl;
        ostr << "----------------------" << std::endl;
    }

When it is called as: Collection<Pair, 50> colDictionary;

But this only works if the type is Pair, as well as the exact CAPACITY is 50.

This is what I had in mind, allowing for type to be Pair and CAPACITY to be anything:

    void Collection<Pair>::display(std::ostream& ostr) const
    {
        ostr << "----------------------" << std::endl;
        ostr << "| This is a Pair |" << std::endl;
        ostr << "----------------------" << std::endl;
    }

But this causes a "too few arguments for class template" error.

Any way to do this without changing the actual class template itself?

Answer 1

It's called a partial template specialization :

template <class T, unsigned Capacity>
struct Collection {

};

template <unsigned Capacity>
struct Collection<Pair, Capacity> {
  // Specialize
};

One thing to note is that you cannot partially specialize a single function. You have to specialize the whole class template, which is irritating if the class template is long. Another quick-and-dirty way of doing this if you want to specialize a single function would be to just use a "compile-time if":

#include <type_traits>

template <class T, unsigned Capacity>
struct Collection {
  void display() const {
    if constexpr (std::is_same_v<T, Pair>) {
      // pair implementation
    } else {
      // general implementation
    }
  }
};

Or, as a more clean solution, try moving the whole thing out of the class and add a simple overload:

// Free-standing overloads:

template <class T, unsigned Capacity>
void diplay(Collection<T, Capacity> const& c) { /* ... */ }

template <unsigned Capacity>
void display(Collection<Pair, Capacity> const& c) { /* ... */ }


// The member function delegates the work to
// the overloaded functions. No template specialization
// is involved:

template <class T, unsigned Capacity>
struct Capacity {
  void display() const {
    display(*this); // calls the correct overload.
  }
};

Answer 2

It seems difficult to do a partial specification.

Some ways are helpful for you to achieve it:

1. Define a specification class for this type situation.
2. If you just only desire to custom this behavior(but not too much and it's limited), you can use if-constexpr branches.
3. If you want to avoid a class-partial-template (because it's a burden to rewrite all codes), then use a global function template is helpful.

Some suggested codes are given:

#include <iostream> 

template <typename T, unsigned capacity> 
class Collection {
    public: 
    void display(std::ostream &ostr = std::cout) const; 
}; 

template <typename T, unsigned c> 
void Collection<T, c>::display(std::ostream &ostr) const {
    if constexpr (c == 50u) {
        ostr << "Specification! \n"; 
    } else {
        ostr << "Normal Realization. \n"; 
    }
}

int main() {
    Collection<int, 50> c; 
    c.display(); 
}

Answer 3

If you need to specialize a certain member function, you can use the Curiously Recurring Template Pattern (or CRTP for short). You'd then create a base class and a specialization of that base class. Both contain only the specific member function that you want to specialize.

template <class T, class CRTP, unsigned Capacity>
struct display_impl {
    void display() const {
        auto& This = static_cast<const CRTP&>(*this);
        // Use `This` to access members of Collection
    }
};

template <class CRTP, unsigned Capacity>
struct display_impl<Pair, CRTP, Capacity> {
    void display() const {
        auto& This = static_cast<const CRTP&>(*this);
        // Use `This` to access members of Collection
    }
};

Collection will now inherit from display_impl and supply itself as a template parameter:

template <class T, unsigned Capacity>
struct Collection : display_impl<T, Collection<T, Capacity>, Capacity> {
    friend struct display_impl<T, Collection<T, Capacity>, Capacity>;
};

Demo