C++旅程第10站——类模板2

这是她

Concern for someone else was a good remedy for taking the mind off one's own troubles.


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


类模板中成员变量和普通类中成员函数创建时机区别：
1、普通类的成员函数一开始就可以创建
2、类模板的成员函数在调用时才创建

#include<iostream>

using namespace std;

class Student1
{
        public:
                void Showstudent1()
                {
                        cout << "Student1!!!!!!!!!!!!!!!!!" << endl;
                }
};

class Student2
{
        public:
                void Showstudent2()
                {
                        cout << "Student2!!!!!!!!!!!!!!!!!" << endl;
                }
};

template<class T>
class Class
{
        public:
        
                T a;
                
                //类模板中的成员函数并不是一开始就创建的，而是在模板调用的时在生成 
                
                void func1()
                {
                        a.Showstudent1();
                }        
                
                void func2()
                {
                        a.Showstudent2();
                }
};

void test1()
{
        //模板中的成员函数，比如fun1()，fun2()，只有在程序运行的时候才会被创建。
        
        Class<Student1> p1;
        p1.func1();
        p1.func2();//编译报错 --Student1类中没有func2()函数 
        
        Class<Student2> p2;
        p2.func1();//编译报错 --Student2类中没有func1()函数 
        p2.func2();
}

int main()
{
        test1();
        
        return 0;
} 

类模板对象做函数参数


传入方式：
1、指定传入的类型              ——直接显示对象的数据类型
2、参数模板化                    ——将对象中的参数变成模板进行传递
3、整个类模板化                 ——将这个对象类型模板化进行传递

#include<iostream>
#include<string>

using namespace std;

//定义一个模板类 
template<class T1,class T2>
class Person
{
        public:
                T1 m_name;
                T2 m_age;
                
                Person(T1 name,T2 age)
                {
                        this->m_name = name;
                        this->m_age = age;
                }
                
                void showperson()
                {
                        cout << "name : " << this->m_name << "  age : " << this->m_age << endl; 
                }
};

//1、指定传入类型 （常用） 
void Aperson(Person<string,int>&p)//传入引用 
{
        p.showperson();
} 

void test1()
{
        Person<string,int>p("猪头肉",100);
        Aperson(p);
}

//2、参数模板化
template<class T1,class T2>
void Bperson(Person<T1,T2>&p) 
{
        p.showperson();
}

void test2()
{
        Person<string,int>p("螺狮粉",90);
        Bperson(p);
}

//3、整个类模板化
template<class T>
void Cperson(T &p)
{
        p.showperson();
}

void test3()
{
        Person<string,int>p("烤猪蹄",80);
        Cperson(p);
}

int main()
{
        test1();
        
        test2();
        
        test3();
        
        return 0;
}

类模板与继承


当类模板碰到继承时，注意一下几点：
1、当子类继承的父类是一个类模板时，子类在声明的时候，要指定出父类的中T的类型
2、如果不指定，编译器无法给予子类分配内存
3、如果想灵活指定出父类中T的类型，子类也需变为类模板

#include<iostream>

using namespace std;

template<class T>
class Person
{
        public:
                T m;        
};

//class Person1 : public Person //错误  C++编译需要给子类分配内存，必须直到父类中T的类型才可以向下继承
class Person1 : public Person<int>//必须指定一个类型 
{
        
};

void test1()
{
        Person1 p1;
}

//如果想灵活指定父类中T类型，子类也需要变类模板 
template<class T1,class T2>
class Person2 : public Person<T2>
{
        public:
                T1 s;
};

void test2()
{
        Person2<int,char>p2;//int->T1  char->T2 父类中T 
}

int main()
{
        test1();
        
        test2();
        
        return 0;
}

                                                                  让我看看是谁再看