C++中的模板

        这段时间学习到了c++的领域，也有了很多感悟，碰到了很有意思的函数模板和类模板，接下来分享给大家。        

如下图所示，三个函数功能相同，只是类型不同，却要分别写成三个，非常的不方便。

模板：数据类型参数化

解决问题：减少逻辑冗余，只要用一个模板就可以代替多个函数

模板的分类：

函数模板：本质不是函数，不占内存空间的；只有在调用的时候才会根据你给的数据类型生成对应的函数（系统自动帮你生成的）。

函数模板格式：template<typename T>//typename也可以是class

               T 函数名(T 参数名，T参数名)

例：多个参数，且参数类型与返回值类型相同的函数定义
            template <typename T>
            T add( T a, T b) 
            {
                return a + b;
            }

下面代码是对函数模板的体现，大家可以通过代码理解。

#include <iostream>

using namespace std;

#include <string>

template<typename T, typename T1>

void printArry(T* arry, T1 size)

{                                

    int i = 0;

    for (i=0;i<size;i++)

    {

        cout << arry[i] << endl;

    }

}

template<typename T,int>

void printArry(T* arry, int size)

{

    int i = 0;

    for (i = 0; i < size; i++)

    {

 cout << arry[i] << endl;

    }

}

类模板与函数模板大同小异，不难理解。

类模板格式

template<类型参数表>

class 类模板名

{

        成员函数和成员变量

}；

例：template <typename T>
            class A 
            {
            public : 
                A( T num)
                :m_TNum(num)
                {}
                ~A()
                {}
                void func( T data )
                {
                    m_TNum = data;
                }
            protected/private:
                T m_TNum;
            };
            
            int main()
            {
                A<int> a(3);
                a.func(5);
                return 0;
            }

类模板中的成员函数都函数模板！

 下面的代码是写的一个链表，体现了类模板。

#include <iostream>
using namespace std;
// 节点类
template<class T>
class Node
{
public:
    Node()
    {
        this->pnext = nullptr;
    }
    ~Node() {}
    T data;
    Node<T>* pnext;
};
//链表类
template<class T>
class Clist
{
public:
    Clist();
    ~Clist();
    void push_back(T data);//尾巴处插入
    void printNode();
    int getCount();
private:
    Node<T>* head;//链表头
    int count;//统计存入的数据有几分
};
template<class T>
Clist<T>::Clist()
{
    this->head = new Node<T>;
    this->count = 0;
}
template<class T>
Clist<T>::~Clist()
{
    delete this->head;
}
template<class T>
void Clist<T>::push_back(T data)
{
    Node<T>* ptemp = this->head;
    while (ptemp->pnext!=nullptr) 
    {
        ptemp = ptemp->pnext;
    }
    Node<T>* newNode = new Node<T>;
    newNode->data = data;
    // 
    ptemp->pnext = newNode;

    this->count++;

}//尾巴处插入
template<class T>
void Clist<T>::printNode()
{
    Node<T>* ptemp = this->head;
    while (ptemp->pnext != nullptr)
    {
        ptemp = ptemp->pnext;
        cout << ptemp->data << endl;
    }
}
template<class T>
int Clist<T>::getCount()
{
    return this->count;
}

int main()
{
    Clist<int> intList;
    intList.push_back(100); 
    intList.push_back(200);
    intList.push_back(300);
    intList.push_back(400);

    cout << intList.getCount() << endl;
    intList.printNode();
    return 0;
}