day13,今天学的类模板操作
类模板
建立一个通用类 ， 类中的成员数据类型可以不具体指定，用一个虚拟的类型代表。
语法 template
现在来创建一下类模板
template
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);
p1.showperson();
} 类模板和函数模板的区别
类模板没有自动类型推导的使用方式
类模板在模板参数列表中可以有默认参数
1、类模板没有自动类型推导的使用方式
template
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 p1("Tom" , 18);//正确
p1.showperson();
} 2、类模板在模板参数列表中可以有默认参数
template // 当我们知道有一个参数的数据类型的时候，可以使用这个
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()
{
Personp1("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 Myclass
{
public:
T obj ;
void func1()
{
obj.showPerson1();
}
void func2()
{
obj.showPerson2();
}
};
void test01()
{
Myclassm;
m.func1();
m.func2(); // 报错，因为不在person1中 ， person1 无法访问
} 上述代码如果不写test函数，也不进行func1 func2的调用，直接生成解决方案，会发现不会出现错误，因为类模板中的成员函数一开始系统并不会去调用，只有当使用的时候才会去调用，但是一旦写了test 并且Myclass传入的是Person1的类 ， 调用m.func2的时候会发生错误，这是因为p1的类无法访问p2的类。
类模板对象做函数参数
类模板实例化出的对象，向函数传参的方式
template
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& p1)
{
p1.showperson();
}
void test01()
{
Personp1("Tom", 18);
printPerson1(p1);
} 直接将类p1的数据类型Person
2、参数模板化 -- 将对象中的参数变为模板进行传递
template
void printPerson2(Person& p2)
{
p2.showperson();
//查看如何推出T1的数据类型
cout << "T1的数据类型： " << typeid(T1).name() << endl;
cout << "T2的数据类型： " << typeid(T2).name() << endl;
}
void test02()
{
Personp2("Sam", 18);
printPerson2(p2);
} 这边其实printPerson2是一个函数模板 ，函数模板中会有自动类型推导的使用方式，因此编辑器能自动推导出T1,T2的类型。
3、整个类模板化 -- 将这个对象类型 模板化进行传递
template
void printPerson3(T & p3)
{
p3.showperson();
cout << "T的数据类型： " << typeid(T).name() << endl;
}
void test03()
{
Personp3("Amy", 18);
printPerson1(p3);
} 2、3都是用了函数模板的概念，可以自动类型推导，在第三个整个类模板化就是把类型当作T，让编辑器自动推导数据类型。
这里有个新的知识点，就是查看T的数据类型，可以通过typeid().name()函数来实现。
类模板与继承
当子类继承的父类是一个类模板时，要指定父类中模板T的数据类型 ， 如果不指定数据类型，编译器无法给其分配内存 ， 如果子类想要灵活利用父类中的T，那么子类也要是一个模板。
template
class Base
{
public:
T1 m_name ;
T2 m_age;
}
//class Son : public Base//按照正常继承来写 ，显示缺少类模板base的参数列表
class Son : public Base
{
}
void test01()
{
Son s1;
}
int main()
{
test01();
system("pause");
return 0 ;
} template
class Base
{
public:
T1 m_name ;
}
//灵活利用T
template
class Son : public Base
{
public:
Son1()
{
cout << "T1的数据类型：" << typeid(T1).name() << endl;
cout << "T2的数据类型：" << typeid(T2).name() << endl;
}
T1 mm;
}
void test01()
{
Sons1;
}
int main()
{
test01();
system("pause");
return 0 ;
} 类模板分文件编写
问题产生原因：类模板中成员函数创建是在调用的时候，导致份文件编写时链接 不到
解决方案：1 、将类写成.h 文件和.cpp文件，然后直接在源文件中 #include“xxx.cpp”
2、将类的定义和实现写到同一个文件中，并将其后缀名命名为.hpp即可
//person.hpp
template
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
Person::Person(T1 name , T2 age)
{
this->m_name = name ;
this->m_age = age ;
}
template
void Person::showperson()
{
cout << "姓名： " << this->m_name << "年龄： " << this->m_age << endl;
}
//源文件
#include
#include
#include"person.hpp"
using namespace std;
void test01()
{
Person p1("Tom" , 18);
p1.showperson();
}
int main()
{
test01();
system("pause");
return 0;
} 总结： 主流的解决方式是第二种，将类模板成员函数写到一起，并将后缀名改为.hpp
类模板与友元
回顾一下 友元有三种属性： 全局函数做友元 类做友元 成员函数做友元
1、全局函数类内实现--直接在类内声明友元即可
template
class Person
{
//全局函数做友元
template
friend void printinfo(Person &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 p ("Tom" , 18);
printinfo(p);
} 2、全局函数类外实现--需要提前让编辑器知道全局函数的存在
template
class Person;
template
void showperson(Person &p)
{
cout << "姓名： " << p.m_name << "年龄： " << p.m_age << endl;
}
template
class Person
{
friend void showperson(Person &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 p ("Tom" , 18);
printinfo(p);
} 如果全局函数类外实现，需要在类之前先创建这个函数，由于showperson函数需要传入person数据类型的类进去，所以又需要在showperson之前先告诉编辑器之后有一个类Person。
总结： 建议全局函数做类内实现，用法简单，编译器可以直接识别