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

Question

如何对模板构造函数进行特化？ 为了更好的理解，我举个代码例子：

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;
}

它带有很多错误。 然后，我在另一篇文章中阅读了一些建议，它正在取代

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

到

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

这还不够。

我错过了什么？而且，它背后的想法是什么？

Answer 1

你想知道如何专门化构造函数Stack<T>::Stack 对于T 的特定值。如图所示：-

#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;
}

哪些输出：-

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

Live demo

Answer 2

只有你的类是模板，而不是你的构造函数，你应该简单地使用

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

如果你想为 Stack<char> 专门化你的构造函数，那就是

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