如何专门化模板化构造函数？

Question

How do I make the specialization on a template constructor? For the purpose of better understandings, I will bring an example of code:

template<typename T>
class Stack {
  private:
    int nelem;
    int size;
    vector<T> stack;

  public:
    ~Stack();
    Stack<T>(int t);
    void push(T data);
    T pop();
    T top();
    int getPosTop(){return (nelem--);};
    void cleanStack(){nelem = 0;};
    bool StackEmpty(){ return (nelem == 0);};
    bool StackFull(){ return (nelem == size);};
};


template <typename T>       // constructor definition here
Stack<T>::Stack<T>(int t){
  size = t;
  nelem = 0;
};

int main(){



return 0;
}

It came with lots of errors. Then, I read on another post, some suggestion , which was replacing

template <typename T>
    Stack<T>::Stack<T>(int t){

to

template <typename T> template <typename T> Stack<T>::Stack<T> (int t){

Which was not sufficient.

What am I missing? And, what is the thinking behind it?

Answer 1

Only your class is template, not your constructor, you should simply use

template <typename T>
Stack<T>::Stack(int t){ /*...*/ }

If you want to specialize your constructor for Stack<char> , it would be

template <>
Stack<char>::Stack(int t){ /*...*/ }

Answer 2

You want to know how to specialize just the constructor Stack<T>::Stack for particular values of T . You do it as illustrated:-

#include <vector>
#include <iostream>

template<typename T>
class Stack {
private:
    std::size_t nelem;
    std::size_t size;
    std::vector<T> stack;

public:
    ~Stack(){};
    Stack<T>(std::size_t n);
    void push(T data);
    T pop();
    T top();
    std::size_t getPosTop(){return (nelem--);};
    void cleanStack(){nelem = 0;};
    bool StackEmpty(){ return (nelem == 0);};
    bool StackFull(){ return (nelem == size);};
};

template <typename T>
Stack<T>::Stack(std::size_t t){
    size = t;
    nelem = 0;
    std::cout << "Constructing a `Stack<T>`\n";
}

template <>
Stack<std::string>::Stack(std::size_t t){
    size = t;
    nelem = 0;
    std::cout << "Constructing a `Stack<T>` with `T` = `std::string`\n";
}

template <>
Stack<int>::Stack(std::size_t t){
    size = t;
    nelem = 0;
    std::cout << "Constructing a `Stack<T>` with `T` = `int`\n";
}

int main() {
    Stack<float> sf{2};
    Stack<int> si{3};
    Stack<std::string> ss{4};
    sf.cleanStack();
    si.cleanStack();
    ss.cleanStack();
    return 0;
}

Which outputs:-

Constructing a `Stack<T>`
Constructing a `Stack<T>` with `T` == `int`
Constructing a `Stack<T>` with `T` == `std::string`

Live demo