c++类模板

1、类模板的定义

 函数模板 的T 可以自动类型推导

 类模板 的T 不可以自动类型推导 必须人为指定。

#include <iostream>

using namespace std;

//类模板定义
template<class T>
class Data
{
public:
    T a;
    T b;
public:
    Data(T a,T b)
    {
        this->a = a;
        this->b = b;
    }
    void showDate()
    {
        cout<<"a = "<<a<<", b = "<<b<<endl;
    }

};

int main(int argc, char const *argv[])
{
    //类模板 必须显示指定T的类型
    //Data ob(10,20)  错误  

    Data<int> ob1(10,20);
    Data<char> ob2('a','b');

    ob1.showDate();
    ob2.showDate();
    return 0;
}

2、类模板的成员函数 在类外实现

#include <iostream>

using namespace std;

//类模板定义
template<class T>
class Data
{
public:
    T a;
    T b;
public:
    Data(T a,T b); 
    void showDate();
};


template<class T>
Data<T>::Data(T a, T b)
{
    this->a = a;
    this->b = b;
}

template<class T>
void Data<T>::showDate()
{

    cout<<"a="<<a<<",b="<<b<<endl;
}

int main(int argc, char const *argv[])
{
    //类模板 必须显示指定T的类型
    //Data ob(10,20)  错误  

    Data<int> ob1(10,20);
    Data<char> ob2('A','B');

    ob1.showDate();
    ob2.showDate();
    return 0;
}

3、类模板作为函数的参数

#include <iostream>

using namespace std;

//类模板定义
template<class T>
class Data
{
public:
    T a;
    T b;
public:
    Data(T a,T b); 
    void showDate();
};


template<class T>
Data<T>::Data(T a, T b)
{
    this->a = a;
    this->b = b;
}

template<class T>
void Data<T>::showDate()
{

    cout<<"a="<<a<<",b="<<b<<endl;
}

//void printData(const Data<int> &b)
void printData(Data<int> ob)
{
    cout<<"a="<<ob.a<<",b  = "<<ob.b<<endl;
}


int main(int argc, char const *argv[])
{
    Data<int> ob(10,20);
    printData(ob);
    
    return 0;
}

4、类模板 派生 普通类

 基类：类模板

 子类：普通类

#include <iostream>

using namespace std;

//类模板
template<class T>
class Base
{
 public:
    T a;
 public:
    Base(){cout<<"Base无参构造"<<endl;}
    Base(T a)
    {
        cout<<"有参构造"<<endl;
        this->a = a;
    }
    ~Base()
    {
        cout<<"Base的析构函数"<<endl;
    }
 };

 //普通类
 class Son:public Base<int>  //继承类模板的时候，必须要确定基类的大小
 {
 public:
    int b;
 public:
    Son()
    {
        cout<<"Son的无参构造"<<endl;
    }
    Son(int a, int b):Base<int>(a),b(b)
    {
        cout<<"Son的有参构造"<<endl;
    }
    ~Son()
    {
         cout<<"Son析构函数"<<endl;
    }
};


int main(int argc, char const *argv[])
{
    Son ob(10, 20);
    cout<<"ob.a="<<ob.a<<", ob.b="<<ob.b<<endl;
    
    return 0;
}

5、类模板 头文件和源文件 分离问题（.hpp）

 建议不分离

 类模板定义和类模板成员函数实现都在.hpp文件中

 data.hpp

#ifndef DATA_H
#define DATA_H

#include <iostream>

using  namespace std;

template<class T>
class Data
{
public:
    T a;
public:
    Data();  //构造函数
    Data(T a);  //有参构造
    void setA(T a);
    T getA(void);
};

template <class T>
Data<T>::Data()
{
    cout<<"无参构造"<<endl;
}

template <class T>
Data<T>::Data(T a)
{   
    this->a = a;
    cout<<"有参构造"<<endl;
}

template <class T>
void Data<T>::setA(T a)
{
    this->a = a;
    return;
}

template <class T>
T Data<T>::getA()
{
    return a;
}

#endif

 main.cpp

#include <iostream>
#include "data.hpp"

using namespace std;

int main(int argc, char const *argv[])
{   
    Data<int> ob;
    ob.setA(100);
    cout<<ob.getA()<<endl;
    
    return 0;
}

 

 

类模板和友元

 1、普通函数 作为 类模板 的友元

//普通函数作为类模板的友元
void printData01(Data<int> ob)
{
   cout<<"a="<<ob.a<<endl;
}

 

 

2、函数模板 作为 类模板的友元

//函数模板 作为 类模板的友元
 template<typename T2>
 void printData02(Data<T2> ob)
 {
    cout<<"a="<<ob.a<<endl;
 }

 

 

#include <iostream>

using namespace std;

//类模板
template<class T>
class Data
{
   friend void printData1(Data<int> ob);

   template<typename T2>friend void printData2(Data<T2> ob);

private:
    T a;
public:
    Data()
    {
        cout<<"无参构造"<<endl;
    }

    Data(T a)
    {
        this -> a = a;
        cout<<"有参构造"<<endl;
    }
 
};


//普通函数作为类模板的友元
void printData1(Data<int> ob)
{
    cout<<"a = "<<ob.a<<endl;
}

//函数模板 作为 类模板的友元
template<typename T2>
void printData2(Data<T2> ob)
{
    cout<<"a = "<<ob.a<<endl;
}


int main(int argc, char const *argv[])
{
    Data<int> ob(100);
    printData1(ob);

    Data<char> ob2('b');
    printData2(ob2);
    
    return 0;
}