day13,今天学的类模板操作

类模板

建立一个通用类 ， 类中的成员数据类型可以不具体指定，用一个虚拟的类型代表。

语法 template <typename T>类

现在来创建一下类模板

template<class T1 , class T2>
class Person
{
public:
    Person( T1 name , T2 age)
    {
        this->m_name = name ;
        this->m_age = age ;
    }
    void showperson()
    {
        cout << "姓名： " << this->m_name << " 年龄： " << this->m_age << endl;
    }
    T1 m_name ;
    T2 m_age;
};

void test01()
{
    Person <string , int>p1("Tom" , 18);
    p1.showperson();
}

类模板和函数模板的区别

类模板没有自动类型推导的使用方式

类模板在模板参数列表中可以有默认参数

1、类模板没有自动类型推导的使用方式

template<class T1 , class T2>
class Person
{
public:
    Person( T1 name , T2 age)
    {
        this->m_name = name ;
        this->m_age = age ;
    }
    void showperson()
    {
        cout << "姓名： " << this->m_name << " 年龄： " << this->m_age << endl;
    }
    T1 m_name ;
    T2 m_age;
};

void test01()
{
    //Person p1("Tom" , 18); // 报错，因为类模板没有自动类型推导的使用方式
    Person <string , int >p1("Tom" , 18);//正确
    p1.showperson();
}

2、类模板在模板参数列表中可以有默认参数

template<class T1 , class T2 = int> // 当我们知道有一个参数的数据类型的时候，可以使用这个
class Person
{
public:
    Person( T1 name , T2 age)
    {
        this->m_name = name ;
        this->m_age = age ;
    }
    void showperson()
    {
        cout << "姓名： " << this->m_name << " 年龄： " << this->m_age << endl;
    }
    T1 m_name ;
    T2 m_age;
};

void test01()
{
    Person<string>p1("Sam",19); // 正确，因为我们在上述指定了T2的数据类型，所以不需要再写T2的数据类型，类模板在模板参数列表中可以有默认参数
    p1.showperson();
}

类模板中成员函数创建时机

class Person1 
{
public:
	void showPerson1() 
	{
		cout << "Person1 show" << endl;
	}
};

class Person2
{
public:
	void showPerson2()
	{
		cout << "Person2 show" << endl;
	}
};

template<class T>
class Myclass
{
public:
    T obj ; 
    void func1()
    {
        obj.showPerson1();
    }
    void func2()
	{
		obj.showPerson2();
	}
};

void test01() 
{
	Myclass<Person1>m;
	m.func1();
	m.func2(); // 报错，因为不在person1中 ， person1 无法访问
}

上述代码如果不写test函数，也不进行func1 func2的调用，直接生成解决方案，会发现不会出现错误，因为类模板中的成员函数一开始系统并不会去调用，只有当使用的时候才会去调用，但是一旦写了test 并且Myclass传入的是Person1的类 ， 调用m.func2的时候会发生错误，这是因为p1的类无法访问p2的类。

类模板对象做函数参数

类模板实例化出的对象，向函数传参的方式

template<class T1, class T2>
class Person 
{
public:
	Person(T1 name , T2 age)
	{
		m_name = name;
		m_age = age; 
	}
	void showperson() 
	{
		cout << "姓名： " << this->m_name << "年龄： " << this->m_age << endl;
	}
	T1 m_name;
	T2 m_age;
};

1、指定传入类型 -- 直接显示对象的数据类型

void printPerson1(Person<string, int >& p1)
{
	p1.showperson();
}


void test01() 
{
	Person<string, int >p1("Tom", 18);
	printPerson1(p1);
}

直接将类p1的数据类型Person<string, int >用引用的方式传入printPerson1函数中，这是最简单的方式，也是之后使用最多的方式。

2、参数模板化 -- 将对象中的参数变为模板进行传递

template<class T1 ,class T2>
void printPerson2(Person<T1, T2>& p2)
{
	p2.showperson();
	//查看如何推出T1的数据类型
	cout << "T1的数据类型： " << typeid(T1).name() << endl;
	cout << "T2的数据类型： " << typeid(T2).name() << endl;
}

void test02() 
{
	Person<string, int >p2("Sam", 18);
	printPerson2(p2);
}

这边其实printPerson2是一个函数模板 ，函数模板中会有自动类型推导的使用方式，因此编辑器能自动推导出T1,T2的类型。

3、整个类模板化 -- 将这个对象类型 模板化进行传递

template <class T>
void printPerson3(T & p3) 
{
	p3.showperson();
	cout << "T的数据类型： " << typeid(T).name() << endl;
}

void test03() 
{
	Person<string, int >p3("Amy", 18);
	printPerson1(p3);
}

2、3都是用了函数模板的概念，可以自动类型推导，在第三个整个类模板化就是把类型当作T，让编辑器自动推导数据类型。

这里有个新的知识点，就是查看T的数据类型，可以通过typeid().name()函数来实现。

类模板与继承

当子类继承的父类是一个类模板时，要指定父类中模板T的数据类型 ， 如果不指定数据类型，编译器无法给其分配内存 ， 如果子类想要灵活利用父类中的T，那么子类也要是一个模板。

template <class T1 , class T2>
class Base
{
public:
    T1 m_name ;
    T2 m_age;
}

//class Son : public Base//按照正常继承来写 ，显示缺少类模板base的参数列表
class Son : public Base<string , int>
{

}

void test01()
{
    Son s1;
}

int main()
{
    test01();
    system("pause");
    return 0 ; 
}

template <class T1>
class Base
{
public:
    T1 m_name ;
}

//灵活利用T
template <class T1, class T2>
class Son : public Base<T2>
{
public:
    Son1() 
	{
		cout << "T1的数据类型：" << typeid(T1).name() << endl;
		cout << "T2的数据类型：" << typeid(T2).name() << endl;
    }
    T1 mm;
}

void test01()
{
    Son<int ,string>s1;
}

int main()
{
    test01();
    system("pause");
    return 0 ; 
}

类模板分文件编写

问题产生原因：类模板中成员函数创建是在调用的时候，导致份文件编写时链接 不到

解决方案：1 、将类写成.h 文件和.cpp文件，然后直接在源文件中 #include“xxx.cpp”

2、将类的定义和实现写到同一个文件中，并将其后缀名命名为.hpp即可

//person.hpp
template<class T1 , class T2>
class Person
{
public:
    Person(T1 name , T2 age);
    void showperson();
    {
        cout << "姓名： " << this->m_name << "年龄： " << this->m_age << endl;
    }
    
    T1 m_name ;
    T2 m_age ;
};

template<class T1 , class T2>
Person<T1 , T2>::Person(T1 name , T2 age)
{
    this->m_name = name ;
    this->m_age = age ;
}
template<class T1 , class T2>
void Person<T1 , T2>::showperson()
{
    cout << "姓名： " << this->m_name << "年龄： " << this->m_age << endl;
}

//源文件
#include<iostream>
#include<string>
#include"person.hpp"
using namespace std;

void test01()
{
    Person <string , int >p1("Tom" , 18);
    p1.showperson();
}

int main()
{
    test01();
    system("pause");
    return 0;
}

总结： 主流的解决方式是第二种，将类模板成员函数写到一起，并将后缀名改为.hpp

类模板与友元

回顾一下 友元有三种属性： 全局函数做友元   类做友元  成员函数做友元

1、全局函数类内实现--直接在类内声明友元即可

template<class T1 , class T2>
class Person 
{
    //全局函数做友元
    template<class T1 , class T2>
    friend void printinfo(Person<T1 ,T2> &p)
    {
        cout << "姓名： " << p.m_name << "年龄： " << p.m_age << endl;
    }

public:
    Person(T1 name , T2 age )
    {
        this->m_name = name ;
        this->m_age = age ;
    }
private:
    T1 m_name ;
    T2 m_age ;
};

void test01()
{
    Person<string , int > p ("Tom" , 18);
    printinfo(p);
}

2、全局函数类外实现--需要提前让编辑器知道全局函数的存在

template<class T1 , class T2>
class Person;
template<class T1 , class T2>
void showperson(Person<T1,T2> &p)
{
   cout << "姓名： " << p.m_name << "年龄： " << p.m_age << endl;
}
template<class T1 , class T2>
class Person 
{
    friend void showperson(Person<T1,T2> &p);
    
public:
    Person(T1 name , T2 age )
    {
        this->m_name = name ;
        this->m_age = age ;
    }
private:
    T1 m_name ;
    T2 m_age ;
};



void test01()
{
    Person<string , int > p ("Tom" , 18);
    printinfo(p);
}

如果全局函数类外实现，需要在类之前先创建这个函数，由于showperson函数需要传入person数据类型的类进去，所以又需要在showperson之前先告诉编辑器之后有一个类Person。

总结： 建议全局函数做类内实现，用法简单，编译器可以直接识别