类模板与模板类

类模板：仅仅的类的抽象

类模板的实例化就是

使用与函数模板也差不多，只是要，直接使用例子看类模板。

//类模板
template <typename T, size_t kSize = 10>//类型参数T与非类型参数kSize
class Stack
{
public:
    Stack()
    : _top(-1)
    , _data(new T[kSize]())
    {
    }
    ~Stack();
    bool empty() const;
    bool full() const;
    void push(const T &t);
    void pop();
    T top() const;
private:
    int _top;
    T *_data;
    };
//类模板在类外面定义成员函数时候需要注意，模板是有类型的，需要使用参数加类型
template <typename T, size_t kSize>
Stack<T, kSize>::~Stack()
{
    if(_data)
    {
        delete [] _data;
        _data = nullptr;
    }
}
template <typename T, size_t kSize>
bool Stack<T, kSize>::empty() const
{
    return -1 == _top;//_top = -1
}
template <typename T, size_t kSize>
bool Stack<T, kSize>::full() const
{
    return _top == kSize - 1;
}
template <typename T, size_t kSize>
void Stack<T, kSize>::push(const T &t)
{
    if(!full())
    {
        _data[++_top] = t;
    }
    else
    {
        cout << "The Stack is full, cannot push any data" << endl;
    }
}
template <typename T, size_t kSize>
void Stack<T, kSize>::pop()
{
    if(!empty())
    {
        --_top;
    }
    else
    {
        cout << "The Stack is empty" << endl;
    }
}
template <typename T, size_t kSize>
T Stack<T, kSize>::top() const
{
    return _data[_top];
}
void test()
{
    Stack<int, 8> st;
}
void test1()
{
    Stack<string> st;
}

模板的嵌套

template<class T>
class Outside       
{
public:
    template <class R>
    class Inside        
    {
    public:
        Inside(R x) 
        {
            r = x;
        }
        void disp() {cout << "Inside: " << r << endl;}
    private:
        R r;
    };
    Outside(T x) : t(x) 
    {}
    
    void disp()
    {
        cout<<"Outside:";
        t.disp();
    }
private:
    Inside<T> t;
};
void test()
{
    Outside<int>::Inside<double> obin(3.5); 
    obin.disp();
    Outside<int> obout(2);  
    obout.disp();
}

C++模板的特化(specialization)和偏特化(partial specialization)_模板偏特化-CSDN博客