第八层：模板(下）-阿里云开发者社区

代码验证：

#include<iostream>
using namespace std;
class A1
{
public:
  void print1()
  {
  cout << "A1在被调用" << endl;
  }
};
class A2
{
public:
  void print2()
  {
  cout << "A2在被调用" << endl;
  }
};
template<class T>
class A
{
public:
  void print1()
  {
  T a;
  a.print1();
  }
  void print2()
  {
  T a.print2();
  }
};
void test1()
{
  A<A1> a;
  a.print1();
  a.print2();
}
int main()
{
  test1();
  return 0;
}

代码在没有运行的时候，没有报错，在运行之后，会发现内部编译错误，是因为通用类型被定义为A1，A1中没有print2函数，现在注释掉，在来看看：

#include<iostream>
using namespace std;
class A1
{
public:
  void print1()
  {
  cout << "A1在被调用" << endl;
  }
};
class A2
{
public:
  void print2()
  {
  cout << "A2在被调用" << endl;
  }
};
template<class T>
class A
{
public:
  void print1()
  {
  T a;
  a.print1();
  }
  //void print2()
  //{
  //  T a.print2();
  //}
};
void test1()
{
  A<A1> a;
  a.print1();
  //a.print2();
}
int main()
{
  test1();
  return 0;
}

可以调用，这就是因为在确定通用类型之前没有生成内部函数，在确定好之后，会创建成员函数。

类模板对象做函数参数

类模板实例化出来的对象，可以做函数的参数吗？可以而且方法还不少：

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

2.参数模板化：将对象中的参数变成模板进行传递

3.整个类模板化：将整个对象模型模板化进行传递

指定传入类型

指定传入类型怎么去做？下面用代码来演示：

#include<string>
#include<iostream>
using namespace std;
template<class T1,class T2>
class per
{
public:
  per(T1 a, T2 b)
  {
  _name = a;
  _age = b;
  }
  T1 _name;
  T2 _age;
};
void print(per<string, int> p)
{
  cout << p._name << "的年龄" << p._age << "岁" << endl;
}
void test1()
{
  per<string, int> p("张三",18);
  print(p);
}
int main()
{
  test1();
  return 0;
}

直接将对象名前面的类名和模板的数据类型传过去就可以。

参数模板化

参数模板化，顾名思义，就是将参数变成和模板一样，模板有什么特点？通用的数据类型，就其实就是将模板的参数列表变成通用的数据类型即可：

#include<string>
#include<iostream>
using namespace std;
template<class T1,class T2>
class per
{
public:
  per(T1 a, T2 b)
  {
  _name = a;
  _age = b;
  }
  T1 _name;
  T2 _age;
};
template<class T1,class T2>
void print(per<T1,T2> p)
{
  cout << p._name << "的年龄" << p._age << "岁" << endl;
}
void test1()
{
  per<string, int> p("张三",18);
  print(p);
}
int main()
{
  test1();
  return 0;
}

将对象模型进行模板化

将对象模型进行模板化，就是将对象变成一个通用类型：

#include<string>
#include<iostream>
using namespace std;
template<class T1,class T2>
class per
{
public:
  per(T1 a, T2 b)
  {
  _name = a;
  _age = b;
  }
  T1 _name;
  T2 _age;
};
template<class T>
void print(T p)
{
  cout << p._name << "的年龄" << p._age << "岁" << endl;
}
void test1()
{
  per<string, int> p("张三",18);
  print(p);
}
int main()
{
  test1();
  return 0;
}

类模板和继承

既然都是类，那类模板可以作为父类吗？被继承吗？是可以的，但是有需要注意的地方：

1.当子类继承的父类是一个类模板的时候，子类在声明的时候，要指出父类中通用类型的类型

2.如果不指定，编译器无法给子类分配内存

3.如果想灵活的指出父类中通用类型的类型，子类也需要变成类模板

第一点和第二点

因为在子类中会继承父类中的所有非静态成员变量，这个时候如果不知道父类中成员是什么类型，则编译器不知道应该分配多少内存给子类当中，所以要指定出来，那怎么指定呢？写法：

class 子类 : 继承方式父类< 指定出类型 >

代码验证：

#include<iostream>
using namespace std;
template<class T1,class T2>
class per
{
public:
  per(T1 a, T2 b)
  {
  _name = a;
  _age = b;
  }
  T1 _name;
  T2 _age;
};
class per1 :public per
{
public:
};
int main()
{
  return 0;
}

这个时候没有写，报错。

#include<string>
#include<iostream>
using namespace std;
template<class T1,class T2>
class per
{
public:
  per(T1 a, T2 b)
  {
  _name = a;
  _age = b;
  }
  T1 _name;
  T2 _age;
};
class per1 :public per<string ,int>
{
public:
};
int main()
{
  return 0;
}

写上之后不报错。

灵活指出父类中的类型

那怎么样才能灵活的指出呢？这个时候将子类变成模板即可：

#include<string>
#include<iostream>
using namespace std;
template<class T1,class T2>
class per
{
public:
  per(T1 a, T2 b)
  {
  _name = a;
  _age = b;
  }
  T1 _name;
  T2 _age;
};
template<class T,class T1>
class per1 :public per<T,T1>
{
public:
};
int main()
{
  return 0;
}

这个时候，这个T和T1就指向的是父类中的两个通用模板：

类模板成员函数类外实现

普通类的成员函数可以在类外实现，那类模板的是否可以？是可以的，有一定的语法格式，不仅仅要加作用域：

template < class T >

返回类型类名< 参数 >:: 函数名（T ____）

构造函数也可以进行类外实现，用代码验证一下：

#include<string>
#include<iostream>
using namespace std;
template<class T1,class T2>
class per
{
public:
  per(T1 a, T2 b);
  T1 _name;
  T2 _age;
};
template<class T1,class T2>
per<T1, T2>::per(T1 a, T2 b)
{
  _name = a;
  _age = b;
  cout << _name << "的年龄为" << _age << endl;
}
void test1()
{
  per<string, int>p("张三", 18);
}
int main()
{
  test1();
  return 0;
}

类模板的分文件编写

当代码量过大时，程序员通常会选择分文件编写，将声明实现和调用分开，那模板分开可以正常使用吗？

验证：

test.cpp

#include"per.h"
void test1()
{
  per<string, int>p("张三", 18);
}
int main()
{
  test1();
  return 0;
}

per.cpp

#include"per.h"
template<class T1, class T2>
class per
{
public:
  per(T1 a, T2 b)
  {
  _name = a;
  _age = b;
  cout << _name << "的年龄为" << _age << endl;
  }
  T1 _name;
  T2 _age;
};

per.h

#pragma once
#include<string>
#include<iostream>
using namespace std;
template<class T1, class T2>
class per;

是报错的，那这是为什么？上面说到，对于类模板中的成员函数在编译器阶段才去创建的，我们包含的头文件，那这个时候编译器就不会看到实现部分，只看到了声明，那这个时候可以将引的头文件该成实现的模块：

#include"per.cpp"
void test1()
{
  per<string, int>p("张三", 18);
}
int main()
{
  test1();
  return 0;
}

是可以正常使用的，那这个时候还可以将声明和实现放在一起，任何将后缀改为hpp，其他也可以，只是hpp是约定俗成的，一看上去就知道是模板的实现和定义。

类模板和友元

那类模板可以有友元函数吗？是可以拥有的，分为类内实现和类外实现

类内实现

类内实现直接在类捏将函数功能实现出来即可：

template<class T1,class T2>
class per
{
  friend void print(per<T1, T2> &p)
  {
  cout << _name << "的年龄为" << _age << endl;
  }
public:
  per(T1 a, T2 b)
  {
  _name = a;
  _age = b;
  }
private:
  string _name;
  int _age;
};

类外实现

template<class T1,class T2>
class per
{
  friend void print< >(per<T1, T2>& p);
public:
  per(T1 a, T2 b)
  {
  _name = a;
  _age = b;
  }
private:
  string _name;
  int _age;
};

类外实现时要注意，需要提前让编译器知道它存在，所以声明在类模板中。

注意

掌握模板不是为了写模板，而是为了使用第九层中的stl。

第九层…顶层?

看完上面的内容，我便踏入了前往第九层的楼梯，上来之后，抬头便是许久未见的天空…

第八层：模板(下）