作者 青鸟

面向对象简介

c++是一门面向对象的编程语言，其中最为关键的部分在面向对象的实现，面向对象的实现在于类，可以说类是面向对象的基石。

面向对象是以对象为主体的一种思想，而在计算机中的对象指的就是储存在内存中的一带有特定类型的数据。面向对象

面向对象的核心概念可以概括为：数据封装、继承、多态、泛型编程。

  1. 数据封装将一组数据和这组数据有关的操作封装在一起，用户不必知道实现细节，只需要对象提供的外部特性接口访问对象。c++中使用类(class)来完成数据封装。

  2. 类是继承机制的基石。有了类的层次结构和继承性，不同对象的共同性只需要被定义一次。

  3. 所谓多态就是一个接口多种实现。在不同的上下文语境中，使用同一个接口会得到不同的响应。在c++中接口的实现就是函数。多态的概念用在函数上就是函数重载。

  4. 很多代码除了数据类型以外，其他都差不多。泛型编程就是以一种独立于任何特定类型的方式来编写代码。实际上是一种特殊的多态，实现的方式是类型的参数化。在c++中。泛型编程主要依靠模板来实现

下面分别来重点介绍后面三种性质：

继承

继承的概念及声明

后代的类对于父类特征的全盘接受的行为就是继承

两个类满足以下的关系：上层分类的全部特性将自动传递给下层分类而无需显示的声明，下层类会逐步增加上层类中没有的特性。

当创建一个类时，我们不需要重新编写新的数据成员和成员函数，只需指定新建的类继承了一个已有的类的成员即可。这个已有的类称为基类，新建的类称为派生类。一个类可以派生自多个类，这意味着，它可以从多个基类继承数据和函数。定义一个派生类，我们使用一个类派生列表来指定基类。类派生列表以一个或多个基类命名，形式如下：

1

class derived-class: access-specifier base-class

其中，访问修饰符 access-specifier 是 public、protected 或 private 其中的一个，base-class 是之前定义过的某个类的名称，我们称为基类。如果未使用访问修饰符 access-specifier，则默认为 private，而derived-class我们称其为派生类。

派生类可以访问基类中所有的非私有成员。因此基类成员如果不想被派生类的成员函数访问，则应在基类中声明为 private。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

// 基类
class Animal {
    // eat() 函数
    // sleep() 函数
};


//派生类
class Dog : public Animal {
    // bark() 函数
};

我们可以根据访问权限总结出不同的访问类型，如下所示：

访问publicprotectedprivate
同一个类yesyesyes
派生类yesyesno
外部的类yesnono

一个派生类继承了所有的基类方法，但下列情况除外：

  1. 基类的析构函数。

  2. 基类的重载运算符。

  3. 基类的友元函数。

假设有一个基类 Shape，Rectangle 是它的派生类，如下所示：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

#include <iostream>
 
using namespace std; 
// 基类
class Shape 
{
   public:
      void setWidth(int w)
      {
         width = w;
      }
      void setHeight(int h)
      {
         height = h;
      }
   protected:
      int width;
      int height;
};
// 派生类
class Rectangle: public Shape
{
   public:
      int getArea()
      { 
         return (width * height); 
      }
};
 
int main(void)
{
   Rectangle Rect;
   Rect.setWidth(5);
   Rect.setHeight(7);
   // 输出对象的面积
   cout << "Total area: " << Rect.getArea() << endl;
   return 0;
}

继承类型

当一个类派生自基类，该基类可以被继承为 public、protected 或 private 几种类型。继承类型是通过上面讲解的访问修饰符 access-specifier 来指定的。

我们几乎不使用 protected 或 private 继承，通常使用 public 继承。当使用不同类型的继承时，遵循以下几个规则：

  1. 公有继承（public）：当一个类派生自公有基类时，基类的公有成员也是派生类的公有成员，基类的保护成员也是派生类的保护成员，基类的私有成员不能直接被派生类访问，但是可以通过调用基类的公有和保护成员来访问。

  2. 保护继承（protected）： 当一个类派生自保护基类时，基类的公有和保护成员将成为派生类的保护成员。

  3. 私有继承（private）：当一个类派生自私有基类时，基类的公有和保护成员将成为派生类的私有成员。

继承的实现原理

同聚集和组合一样，继承是两个类合作的另一种方式。

采用继承方式时，派生类对象是在基类对象的基础上扩展而构建。也就是说，派生类对象的前半部分是一个完整的基类对象（称为基类子对象）。这样一来就可以认为基类的所有成员直接成为派生类的成员，除了基类的私有成员外，派生类还可以访问基类的其他所有成员。但其实“基类的所有成员直接成为派生类的成员”这种说法并不准确。准确的说基类子对象的作用域和派生类的作用域还是严格分开的。

上面这种说法之所可以成立，是因为编译器自己的名字查找机制的作用。当使用一个派生类成员时，名字查找机制首先在自己的作用域中查找该成员是否存在，如果找到则使用它；否则在它的基类中查找（可能直至继承链的顶端），如果找到则使用它，否则会抛出错误。

由此可知，如果一个成员在派生类和基类的作用域中都存在，名字查找机制确保我们使用的是派生类自己的。

可以看出，名字查找机制确保了继承来的成员像是派生类自己的一样。这使得我们用这些成员时，无需显示地穿越作用域界限。特别值得注意的是，需要关注成员的访问属性，以及继承访问控制带来的影响。

同时名字查找机制让基类的某些数据成员可以在派生类中被重新定义，派生类会覆盖基类中的成员。基类中的成员函数也可以被重新定义。这种重载的原理是类作用域的区别加上名字查找机制的保障。

构造函数的继承

如果派生类的构造函数与其基类的功能完全相同，即他们都是初始化只初始化那些二者共同拥有的成员。那么派生类中可以不用显示地定义自己的构造函数，而是使用using声明直接引入基类的构造函数。继承的构造函数会初始化派生类对象中的基类子函数对象。不过这种初始化过程只被看作一次函数调用。

1
2
3
4
5

class D : public B
{
   public:
      using B:B;
};

这里的派生类D继承了B的所有构造函数。甚至包括重载的赋值运算符。

注意：虽然构造函数可以被继承，但是析构函数不行。因为析构函数的作用是释放对象的内存。由于派生类占有的资源极有可能和基类不同，因此基类的析构函数不能被继承。但如果它是虚的，则能被基类覆盖。

基类子对象的初始化

派生类对象包含了一个完整的基类子对象，从内存重解释的角度来看就是：派生类对象可以被重解释为一个基类对象。基于这个事实，在构造派生类对象之前，必须先构建基类子对象。这可以通过在派生类的构造函数的初始化列表中引起基类构造函数的调用实现。

1
2
3
4
5
6

class B :public : A
{
   public:
      B(int x=1,int y=2,std::string n="hello"):
         A(n),width(x),height(y) {}
};

通过上述代码可以看出，在基类构造函数调用时需要向其传递参数。这些参数一般来自于派生类自己的构造函数参数列表

在派生类的构造函数的初始化列表中，只能直接访问其直接基类的构造函数，也只能直接初始化自己的成员。否则会引起一个编译错误。

赋值兼容原则

派生对象中包含了一个基类子对象，这为基类对象和派生对象的赋值兼容奠定了基础。

下面我们假设A是基类,B是派生类。

派生对象和基类对象的赋值

1
2
3

A x;
B y;
x=y;

这样的赋值是允许的。这种赋值将派生对象中属于基类的部分赋值给了基类对象，属于派生对象的部分被舍弃了。这种现象称为切片。

相反的y=x是非法的，这样的操作会生成一个不完整的派生类对象，因此是非法的。

引用作用于派生类和基对象

1
2

B y;
A &x=y;

引用x的初始化是合法的，且x成为了y的别名。

派生类对象赋值给基类的引用不会引起派生类对象到基类对象的转换。我们从类型的角度来理解这种引用绑定：派生类对象y表示了一段内存，通过这个名字来观察这段内存，显然这段内存是属于一个派生类对象的。而通过基类引用名x来观察这段y的内存，这段内存就会被重解释：x认为那是一个基类对象占据的内存，而多出来的只属于派生类对象的部分对x来说是完全看不见的。就是说虽然y有了一个别名，但是使用这两个名字会有完全不同的结果。x会得到一个基类对象，而y会得到一个派生类对象。可以认为x是y派生对象中基类子对象的一个别名。

那么B &y=x根据上述的原理就是不合法的，因为派生对象会多出一段不属于基类对象的内存，这种引用赋值就是非法的、不安全的。

指针作用于派生类和基类对象

1
2

B y;
A *x=&y;

与引用状况一致，以上的初始化是合法的。此时，指针x只看到了属于基类子对象的部分，而其他的部分都会被忽略。 同样的将基类指针赋值给派生类是非法的

多继承

多继承即一个子类可以有多个父类，它继承了多个父类的特性。

C++ 类可以从多个类继承成员，语法如下：

1
2
3
4

class <派生类名>:<继承方式1><基类名1>,<继承方式2><基类名2>,…
{
<派生类类体>
};

其中，访问修饰符继承方式是 public、protected 或 private 其中的一个，用来修饰每个基类，各个基类之间用逗号分隔.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

#include <iostream>
using namespace std;
// 基类 Shape
class Shape 
{
   public:
      void setWidth(int w)
      {
         width = w;
      }
      void setHeight(int h)
      {
         height = h;
      }
   protected:
      int width;
      int height;
};
 
// 基类 PaintCost
class PaintCost 
{
   public:
      int getCost(int area)
      {
         return area * 70;
      }
};
 
// 派生类
class Rectangle: public Shape, public PaintCost
{
   public:
      int getArea()
      { 
         return (width * height); 
      }
};
 
int main(void)
{
   Rectangle Rect;
   int area;
   Rect.setWidth(5);
   Rect.setHeight(7);
   area = Rect.getArea();
   // 输出对象的面积
   cout << "Total area: " << Rect.getArea() << endl;
   // 输出总花费
   cout << "Total paint cost: $" << Rect.getCost(area) << endl;
   return 0;
}

多态

多态按字面的意思就是多种形态。就是一种接口，多种实现。更具体一点，就是在不同的语境中调用相同的方法，会得到不同的结果。

当类之间存在层次结构，并且类之间是通过继承关联时，就会用到多态。

C++ 多态意味着调用成员函数时，会根据调用函数的对象的类型来执行不同的函数。

在C++中，多态分为静态和动态两种，都是通过函数重载来实现的

静态多态

静态多态也被称为早期匹配，其实就是在编译时完成。对于被重载的函数，我们只需要满足每个函数的特征标不同即可。所谓的特征标便是函数的参数列表。

如swap(int,int)和swap(double,double)和swap(int,int,int)三个的特征标都是不相同的，函数传入参数的数据类型或者数量不同时，我们便认为函数的特征标不同。注意：函数的特征表与传入参数的名称没有什么关系，只和类型与数量有关。

动态多态

静态的多态只覆盖了编译阶段的多态状况。在下面的案例中，赋值兼容机制保证了指向派生类的基类指针的正确性，也保证了接口使用的一致性。但也使编译器无法鉴别指针指向的真实对象究竟是属于基类还是派生类。显然这一类问题只有在运行时才能被解决。

在运行时在不同的语境下用统一的接口来识别不同的对象就是动态多态性，而C++中的虚函数机制使得动态多样性成为了可能

下面的实例中，基类 Shape 被派生为两个类，如下所示：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

#include <iostream> 
using namespace std;
class Shape {
   protected:
      int width, height;
   public:
      Shape( int a=0, int b=0)
      {
         width = a;
         height = b;
      }
      int area()
      {
         cout << "Parent class area :" <<endl;
         return 0;
      }
};
class Rectangle: public Shape{
   public:
      Rectangle( int a=0, int b=0):Shape(a, b) { }
      int area ()
      { 
         cout << "Rectangle class area :" <<endl;
         return (width * height); 
      }
};
class Triangle: public Shape{
   public:
      Triangle( int a=0, int b=0):Shape(a, b) { }
      int area ()
      { 
         cout << "Triangle class area :" <<endl;
         return (width * height / 2); 
      }
};
// 程序的主函数
int main( )
{
   Shape *shape;
   Rectangle rec(10,7);
   Triangle  tri(10,5);
   // 存储矩形的地址
   shape = &rec;
   // 调用矩形的求面积函数 area
   shape->area();
   // 存储三角形的地址
   shape = &tri;
   // 调用三角形的求面积函数 area
   shape->area();
   return 0;
}

输出结果如下：

1
2

Parent class area :
Parent class area :

导致错误输出的原因是，调用函数 area() 被编译器设置为基类中的版本，这就是所谓的静态多态，或静态链接 - 函数调用在程序执行前就准备好了。有时候这也被称为早绑定，因为 area() 函数在程序编译期间就已经设置好了。

单靠简单的函数重载是不能实现真正的多态。派生类的方法必须覆盖而不是简单的重载，基类的同原型方法。在C++中覆盖操作是通过虚函数机制来实现。通过覆盖操作，虽然编译器仍认为调用的是基类中的成员，但是覆盖行为起到了偷梁换柱的作用，实际调用的是派生类的版本。

现在，让我们对程序稍作修改，在 Shape 类中，area() 的声明前放置关键字 virtual，如下所示：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

class Shape {
   protected:
      int width, height;
   public:
      Shape( int a=0, int b=0)
      {
         width = a;
         height = b;
      }
      virtual int area()
      {
         cout << "Parent class area :" <<endl;
         return 0;
      }
};

输出结果如下：

1
2

Rectangle class area :
Triangle class area :

此时，编译器看的是指针的内容，而不是它的类型。因此，由于 tri 和 rec 类的对象的地址存储在 *shape 中，所以会调用各自的 area() 函数。

正如您所看到的，每个子类都有一个函数 area() 的独立实现。这就是多态的一般使用方式。有了多态，您可以有多个不同的类，都带有同一个名称但具有不同实现的函数，函数的参数甚至可以是相同的。

虚函数

虚函数 是在基类中使用关键字virtual声明的函数。关键字virtual明确告诉编译器这个函数是一个虚函数，该类派生类中的同名版本将覆盖这个版本。在派生类中重新定义基类中定义的虚函数时，会告诉编译器不要静态链接到该函数。 我们想要的是在程序中任意点可以根据所调用的对象类型来选择调用的函数，这种操作被称为动态链接，或后期绑定。

像这样声明了虚函数的类，或者祖先中包含了虚函数声明的类称为多态类

被virtual关键字修饰的成员函数具有虚特性。虚特性以及呈现虚特性的函数具有以下特点。

  1. 虚特性必须赋给类的成员函数

  2. 虚函数不能是全局函数，也不能是类的静态成员函数

  3. 不能将友元说明为虚函数，但虚函数可以是另一个类的友元

  4. 虚函数特性可以被继承。如果派生类原型一致地重载了基类中的某个虚函数，那么即使在派生类中没有将这个函数显示说明成虚的，它也会被编译器认为是虚的

虚函数的实现原理

为了实现多态，编译器首先会给每个多态类创建一张虚表，表中记录了这个类的所有的虚函数的入口地址。此外编译器还在每一个多态类的对象中设置了一个虚指针，它指向了该类中的虚表

在调用非多态类的成员函数时，编译器会直接找到该函数的入口地址来完成调用。而在调用多态类的虚函数时，编译器会先获得指向对象内置的虚指针(该指针是派生类自己的，而不是基类对象的)，然后在这个虚指针指向的虚表中查询，以获得指定的虚函数的入口地址来完成正确的调用，从而实现了多态。

纯虚函数和抽象类

您可能想要在基类中定义虚函数，以便在派生类中重新定义该函数更好地适用于对象，但是您在基类中又不能对虚函数给出有意义的实现，这个时候就会用到纯虚函数。

声明纯虚函数的语法：

1
2
3
4
5
6

class 基类名
{
   public:
      virtual 成员函数名(参数列表)=0;

};

我们可以把基类中的虚函数 area() 改写如下：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

class Shape {
   protected:
      int width, height;
   public:
      Shape( int a=0, int b=0)
      {
         width = a;
         height = b;
      }
      // pure virtual function
      virtual int area() = 0;
};

= 0 告诉编译器，函数没有主体，上面的虚函数是纯虚函数。

包含纯虚函数声明的类称为抽象类，抽象类支持一般概念的表示，是一种未完成的类型，具有以下特点：

  1. 抽象类只能作用于其他类的基类

  2. 在抽象类的派生类中，即使通过继承还有未完全实现的纯虚函数存在，那么该派生类仍然是一个抽象类

  3. 不能创建抽象类的对象

  4. 可以创建和声明抽象的指针和引用

  5. 抽象类不能用作函数的参数类型和返回类型；但抽象类的指针可以

  6. 抽象类不能作用显示转换的类型

  7. 即使在声明了纯虚函数后，给出了这个函数的实现，这个类依然是抽象类

一般的，我们把所有函数成员都是纯虚函数并且没有数据成员的类称为接口。

泛型编程

泛型编程指的是不依赖任何的具体类型来编写代码，只需要在实例化代码的时候给出具体的数据类型。由于类型的确定在编译之前便已经确定。因此，泛型编程实际上是一种静态的多态。我们将类型参数化，就可以完全兼顾类型检查和减少代码量。

在c++中我们具体的实现依靠模板，使用模板机制进行的程序设计就是泛型编程。

C++中的模板有三类：变量模板、函数模板和类模板。下面分开来介绍。

变量模板

定义和使用类模板

1
2

template <typename T>
T 变量名 = 初始化表达式；

其中的初始化不是必须的

下面给出一个具体的案例：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

#include<iostream>
template <typename T>
T var;

template <typename T>
const T pi=static_cast<T>(3.1415926536);

int main(){
   std::cout<<1.2*1.2*pi<double><<std::endl;
   std::cout<<2*2*pi<int><<std::endl;

   var<int>=9;
   var<std::string>="variable template";
   std::cout<<var<int>','<<var<std::string> <<std::endl;

   return 0;
}

输出的结果如下：

1
2
3

4.52389
12
9,variable template

变量模板只有在被实例化的时候才会真正地产生代码。在上述代码中，类似于pi<int>这样的语法就是变量模板的实例化形式。我们不妨称实例化的变量变量模板为模板变量

变量模板的特化

在前面的例子中，对数值模板pi做了模板化，但这个模板不能处理pi是一个字符串的情况 。在这个情况下，我们要针对这个需求指定一个pi的特别版本。这种特别的版本称为特化

1
2
3

using cstring =const char *;
template <>
cstring pi<cstring>="3.1415926536";

函数模板

函数模板的定义

函数模板使用泛型来定义函数，将类型作为参数传递给模板，函数模板特性本质上也是一种参数化过程，相当于是类型参数化来表示。

定义函数的形式化表示如下：

1
2
3
4

template <typename Anytype1,typename Anytype1,...,类型 常量表达式>
返回值类型 函数名(参数列表){
   函数体
}

在上述的形式化表达中可以看出，函数模板除了类型参数以外，还可以有其他类型的常量参数，这些参数又被称作为非类型参数。非类型参数只能是整数类型(包括所有的整型、字符型、bool型)和枚举类型其中之一。

函数模板并不是一个真正的函数,只是告诉编译器该如何去定义。要让模板工作，我们必须将其实例化，对于实例化的函数，我们称为实例函数或者模板函数。关键字template和typename是必须的，类型名可以任选。

1
2
3
4
5
6
7
8
9

template<typrname Anytype>
void swap(Anytype& &a,Anytype& &b){
    Anytype temp;
    temp=a;
    a=b;
    b=temp;
}
int a{1},b{2};
swap(a,b);

我们可以这么理解swap()的实例化过程：编译器将根据上述给定的参数类型生成下面的模板函数,并在调用点选择与给定参数类型完全匹配的版本，从而实现函数的功能。

1
2
3
4
5
6

void swap<int>(int x,int y){
   int temp;
    temp=x;
    x=y;
    y=temp;
}

我们也可以直接实例化

1

swap<int>(a,b);

除了给出类型参数以外，模板还可以给出非类型参数。在这种情况下，函数模板的实例化参数必须显式的给出，例如：

1
2
3
4
5
6

template<typrname Anytype,Anytype t>
bool judge(Anytype a){
    return a<t;
}
int a{1};
judge<int,1000>(a);

函数模板的所有参数都可以预先取默认值。

1

template<typrname Anytype=int,Anytype t=10>

函数模板的重载

函数模板允许像重载常规函数一样重载模板定义。并且和常规重载一样，被重载的模板的函数特征标必须不同。注意：并非所有的模板参数必须都是模板参数类型，可以有int之类的常规的数据类型。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

template<typrname Anytype>
void swap(Anytype& &a,Anytype& &b){
    Anytype temp;
    temp=a;
    a=b;
    b=temp;
}

void swap(Anytype& &a,Anytype& &b,int n){
    for(int i=0;i<n;i++)
        Anytype temp;
        temp=a;
        a=b;
        b=temp;
}

c++编译器在尝试调用函数模板还是同名的非模板函数时遵循下述规则：

  1. 寻找一个参数完全匹配的非模板函数，如果找到了，就调用它

  2. 否则，寻找一个函数模板，将其实例化并产生一个匹配的模板函数，如果找到了就调用它

  3. 否则，试一下低级的重载，如通过类型转换可产生匹配的函数

  4. 如果均为找到，抛出一个报错

  5. 如果（1）步骤中有多于一个的选择，抛出一个报错

以上是重载的规则

函数模板的显示具体化

有一些类型可能是我们自定义的结构体或者类，这个时候就不能直接使用模板，需要显示具体化（特化）。

显示具体化：提供一个具体的函数定义

需要注意的是：具体化化的时候，特化函数模板的参数必须和普通的函数模板的参数一致

当编译器找到函数，调用匹配的具体化模板后，使用该定义，不再使用模板。、

如果在具体化的时候，只用到了模板参数的部分，那么就把这种特化称为函数模板的部分特化，又称作偏特化。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

template<typrname Anytype>
void swap(Anytype& &a,Anytype& &b){
    Anytype temp;
    temp=a;
    a=b;
    b=temp;
}
template<>void swap<MYstruct>(MYstruct&,MYstruct&);//完全特化
template<>void swap(int,char){};//完全特化
template<typename T>void (T,int){};//偏特化

显示具体化和显示实例化

显示示例化意味着直接命令编译器创建特定的实例，swap<int>()或者 template void swap<int>(int&,int&);,该声明为swap生成int类型实例。

显示具体化是不使用函数模板来生成定义，专门为特定的类型显示化定义函数。这些原型函数必须有自己的定义template<>void swap<MYstruct>(MYstruct&,MYstruct&);

我们使用template和**template<>**来区分显示示例化和显示具体化

完美转发机制

完美转发指的是函数模板可以将自己的参数“完美”地转发给内部调用的其它函数。所谓完美，即不仅能准确地转发参数的值，还能保证被转发参数的左、右值属性不变。

在 C++ 中，一个表达式不是左值就是右值。关于左右值的判断，可位于赋值号（=）左侧的表达式就是左值；反之，只能位于赋值号右侧的表达式就是右值。有名称的、可以获取到存储地址的表达式即为左值；反之则是右值。

值得一提的是，左值的英文简写为“lvalue”，右值的英文简写为“rvalue”。很多人认为它们分别是"left value"、“right value” 的缩写，其实不然。lvalue 是“loactor value”的缩写，可意为存储在内存中、有明确存储地址（可寻址）的数据，而 rvalue 译为 “read value”，指的是那些可以提供数据值的数据（不一定可以寻址，例如存储于寄存器中的数据）。

1
2
3
4

template<typename T>
void function(T t) {
    otherdef(t);
}

如上所示，function() 函数模板中调用了 otherdef() 函数。在此基础上，完美转发指的是：如果 function() 函数接收到的参数 t 为左值，那么该函数传递给 otherdef() 的参数 t 也是左值；反之如果 function() 函数接收到的参数 t 为右值，那么传递给 otherdef() 函数的参数 t 也必须为右值。

显然，function() 函数模板并没有实现完美转发。一方面，参数 t 为非引用类型，这意味着在调用 function() 函数时，实参将值传递给形参的过程就需要额外进行一次拷贝操作；另一方面，无论调用 function() 函数模板时传递给参数 t 的是左值还是右值，对于函数内部的参数 t 来说，它有自己的名称，也可以获取它的存储地址，因此它永远都是左值，也就是说，传递给 otherdef() 函数的参数 t 永远都是左值。总之，无论从那个角度看，function() 函数的定义都不“完美”。

在c++11之前，通过函数重载来实现完美转发，将一个传入参数类型声明为const T& 即可接受右值变量。

显然，使用重载的模板函数实现完美转发也是有弊端的，此实现方式仅适用于模板函数仅有少量参数的情况，否则就需要编写大量的重载函数模板，造成代码的冗余。为了方便用户更快速地实现完美转发，C++ 11 标准中允许在函数模板中使用右值引用来实现完美转发。

C++11 标准中规定，通常情况下右值引用形式的参数只能接收右值，不能接收左值。但对于函数模板中使用右值引用语法定义的参数来说，它不再遵守这一规定，既可以接收右值，也可以接收左值（此时的右值引用又被称为“万能引用”）。

仍以 function() 函数为例，在 C++11 标准中实现完美转发，只需要编写如下一个模板函数即可：

1
2
3
4

template <typename T>
void function(T&& t) {
    otherdef(t);
}

此模板函数的参数 t 既可以接收左值，也可以接收右值。但仅仅使用右值引用作为函数模板的参数是远远不够的，还有一个问题继续解决，即如果调用 function() 函数时为其传递一个左值引用或者右值引用的实参，如下所示：

1
2
3
4
5

int n = 10;
int & num = n;
function(num); // T 为 int&
int && num2 = 11;
function(num2); // T 为 int &&

其中，由 function(num) 实例化的函数底层就变成了 function(int & & t)，同样由 function(num2) 实例化的函数底层则变成了 function(int && && t)。要知道，C++98/03 标准是不支持这种用法的，而 C++ 11标准为了更好地实现完美转发，特意为其指定了新的类型匹配规则，又称为引用折叠规则（假设用 A 表示实际传递参数的类型）： 当实参为左值或者左值引用（A&）时，函数模板中 T&& 将转变为 A&（A& && = A&）； 当实参为右值或者右值引用（A&&）时，函数模板中 T&& 将转变为 A&&（A&& && = A&&）。

读者只需要知道，在实现完美转发时，只要函数模板的参数类型为 T&&，则 C++ 可以自行准确地判定出实际传入的实参是左值还是右值。

通过将函数模板的形参类型设置为 T&&，我们可以很好地解决接收左、右值的问题。但除此之外，还需要解决一个问题，即无论传入的形参是左值还是右值，对于函数模板内部来说，形参既有名称又能寻址，因此它都是左值。那么如何才能将函数模板接收到的形参连同其左、右值属性，一起传递给被调用的函数呢？

C++11 标准的开发者已经帮我们想好的解决方案，该新标准还引入了一个模板函数 forword()，我们只需要调用该函数，就可以很方便地解决此问题。仍以 function 模板函数为例，如下演示了该函数模板的用法：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

#include <iostream>
using namespace std;
//重载被调用函数，查看完美转发的效果
void otherdef(int & t) {
    cout << "lvalue\n";
}
void otherdef(const int & t) {
    cout << "rvalue\n";
}
//实现完美转发的函数模板
template <typename T>
void function(T&& t) {
    otherdef(forward<T>(t));
}
int main()
{
    function(5);
    int  x = 1;
    function(x);
    return 0;
}

从结果中可以看出普通的转发会使参数类型发生变化，而完美转发不会有任何问题

类模板

定义和使用类模板

1
2
3
4
5
6

template <typename Anytype1,typename Anytype1,...,类型 常量表达式>
class 类名{
   //成员定义
}

类名<具体类型>名称;//具体实例化一个变量

与函数模板相同，类模板的非类型参数必须是整数类型的

除了数据成员外，类模板可以包含如下的成员

  1. 成员函数。类模板的所有成员函数都是模板函数，其动态类型一般都依赖于所属模板的类型参数

  2. 成员类。类模板中可能会嵌入一些内部类（不是类对象）的定义。如果这些内部类使用了包围类的类型参数，那么这些类也是类模板。

  3. 成员模板。如果一个在类模板内部的类或者成员函数被冠以template关键字，并且它的类型参数不依赖于包围模板，那么它将称为类模板中的模板，即成员模板。

与函数模板不同，类的实例化必须是显示的，例如：

1
2

list<int>l1{1,2,3,4,5};
list<std::string>{"1","2"};

模板类可以接受非类型参数，我们可以使用这些参数为模板来定制一些特性，例如

1
2

template <typename value_t,size_t maxlen>
class array{private: value_t arr[maxlen];};

同时，类模板的各类参数都可以是默认的。与函数的默认参数相同，类的默认参数只能放在参数列表的最右边。

参考资料：c++程序设计现代方法(白忠建)、c++ primer plus、菜鸟教程