1.C++内联函数

  编译过程的最终产品时可执行程序——有一组机器语言指令组成。运行程序时，操作系统将这些指令载入到计算机内存中，因此每条指令都有特定的内存地址。计算机随后逐步执行这些指令。有时，将跳过一些指令，向前或向后跳到特定地址。常规函数调用也是程序跳到另一个地址，并在函数结束时返回。下面更详细的介绍这一过程的典型实现。执行到函数调用指令时，程序将在函数调用后立即存储该指令的内存地址，并将函数参数复制到堆栈（为此保留的内存块），跳到标记函数起点的内存单元，执行函数代码，然后跳回到地址被保存的指令处。来回跳跃并记录跳跃位置意味着以前使用函数时，需要一定的开销。
  C++内联函数提供另一种选择。编译器将使用相应的函数代码替换函数调用。对于内联代码，程序无需跳到另一个位置处执行代码，再跳回来。因此，内联函数的运行速度比常规函数稍快，但代价是需要占用更多内存。如果程序在10个不同的地方调用同一个内联函数，则该程序将包含该函数代码的10个副本。
  要使用这项特性，必须采取以下之一：

• 在函数声明前加inline
• 在函数定义前加inline

  程序员请求将函数作为内联函数时，编译器不一定会满足这种要求。它可能认为该函数过大或注意到函数调用了自己（内联函数不能递归），因此不将其作为内联函数；而有些编译器没有启用或实现这种特性。

内联与宏
  inline工具是C++新增特性。C语言使用预处理语句#define来提供宏——内联代码的原始实现。
`#define SQUARE(X) X*X
  这并不是通过传递参数实现的，而是通过文本替换来实现——X是“参数”的符号标记。宏不能按值传递。

2.引用变量

  引用是已定义的变量的别名。引用变量的主要用途是用作函数的形参。通过将引用变量用作参数，函数将使用原始数据，而不是其副本。

2.1创建引用变量

  C++给&符号赋予了另一个含义，将其用来声明引用。

int rats;
int & rodents = rats;

  必须在声明引用时将其初始化。引用更像是const指针，必须在创建时进行初始化，一旦与某个变量关联起来，就将一直效忠于它。

2.2将引用用作函数参数

  引用经常被用作函数参数，使得函数中的变量名成为调用程序中的变量的别名。这种传递参数的方法称为按引用传递。

2.3引用的属性和特别之处

double cube(double a)
{a *= a * a;return a;
}
double refcube(double &ra)
{ra *= ra * ra;return ra;
}

  按值传递，可使用多种类型实参：z = cube(x + 2.0);。但如果将参数传递给接受引用参数的函数，传递引用的限制更严格。double z = refcube(x + 3.0);是不合理的，(x + 3.0)不是变量。在现代C++中，大多数编译器将指出这一点，而较老的编译器将发出警告。早期的C++确实允许将表达式传递给引用变量。程序将创建一个临时的无名变量，并将其初始化为(x + 3.0)的值。然后，ra将成为该临时变量的引用。
临时变量、引用参数和const
  如果实参与引用参数不匹配，C++将生成临时变量。当前，仅当参数为const引用时，C++才允许这样做，但以前不是这样的。
  什么时候将创建临时变量？如果引用参数是const，则编译器将在下面两种情况下生成临时变量：

• 实参类型正确，不是左值
• 实参类型不正确，但可以转换为正确的类型
    左值参数是可被引用的数据对象，例如，变量、数组元素、结构成员、引用和解除引用的指针都是左值。非左值包括字面常量（用引号括起的字符串除外，它们由其地址表示）和包括多项的表达式。在C语言中，左值最初指的是可出现在赋值语句左边的实体，但这是引入关键字const之前的情况。现在，常规变量和const变量都可视为左值，因为可通过地址访问它们。

应尽可能使用const

• 避免无意中修改数据的编程错误
• 使函数能够处理const和非const实参，否则只能接受非const数据
• 使函数能够正确生成并使用临时变量
    C++11新增右值引用（rvalue reference）。这种引用可指向右值，是使用&&声明的。新增右值引用的主要目的是，让库设计人员能够提供有些操作的更有效实现。以前的引用（用&声明）被称为左值引用。

double && rref = std::sqrt(36.00);
double j = 15.0;
double && jref = 2.0 * j + 18.5;

2.4将引用用于结构

1. 程序说明
2. 为何要返回引用
     返回引用的函数实际上是被引用的变量的别名。
3. 返回引用时需要注意的问题
     返回引用时最重要的一点是，应避免返回函数终止时不再存在的内存单元引用。为避免这种问题，最简单的方法是，返回一个作为参数传递给函数的引用。另一种方法是用new来分配新的存储空间。
4. 为何将const用于引用返回类型

2.5将引用用于类对象

将C-风格字符串用作string对象引用参数
char指针怎么赋给string引用：首先，string类定义了一种char*到string的转换功能，这使得可以用C-风格字符串来初始化string对象。其次，假设实参的类型和引用参数类型不匹配，但可被转换为引用类型，程序将创建一个正确类型的临时变量，使用转换后的实参值来初始化它，然后传递一个指向该临时变量的引用。

2.6对象、继承和引用

  使得能够将特性从一个类传递给另一个类的语言特性被称为继承。ostream是基类，而ofstream是派生类。派生类继承了基类的方法。继承的另一个特征是基类引用可以指向派生类对象，而无需进行强制类型转换。这种特征的一个实际结果的是，可以定义一个接受基类引用作为参数的函数，调用该函数时，可以将基类对象作为参数，也可以将派生类对象作为参数。

2.7何时使用引用参数

  使用引用参数的原因：

• 修改调用函数中的数据对象
• 通过传递引用而不是整个数据对象，可以提高程序的运行速度
    对于传递值不做修改的函数：
• 数据对象很小，按值传递。
• 数据对象是数组，使用指针，唯一的选择，并声明为指向const的指针。
• 数据对象是较大的结构，使用const指针或const引用，以提高程序的效率。这样可以节省复制结构所需的时间和空间。
• 数据对象是类对象，使用const引用。
    对于修改调用函数中数据的函数：
• 数据对象是内置数据类型，使用指针。
• 数据对象是数组，只能使用指针。
• 数据对象是结构，使用引用或指针。
• 数据对象是类对象，使用引用。

3.默认参数

  默认参数指的是当函数调用中省略了实参时自动使用的一个值。必须通过函数原型设置默认值。对于带参数列表的函数，必须从右向左添加默认值。注意：只有原型指定了默认值，函数定义与没有默认参数是完全相同。

4.函数重载

  函数多态是C++在C语言的基础上新增的功能。可以通过函数重载来设计一系列函数——它们完成相同的工作，但使用不同的参数列表。
  函数重载的关键是函数的参数列表——也称为函数特征标（function signature）。C++允许定义名称相同的函数，条件是它们的特征标不同。

void print(double d, int width); // #1
void print(long l, int width); // #2
void print(int i, int width); // #3unsigned int year = 3210;
print(year, 6);

  它不与任何原型相匹配，C++将尝试使用标准类型转换强制匹配。如果#1是唯一的原型，则函数调用将year转换为double类型，但是有3种转换的方式。这种情况下，C++将拒绝函数调用，并将其视为错误。
  编译器在检查函数特征标时，把类型引用和类型本身视为同一个特征标。

重载引用参数
  类设计和STL经常使用引用参数。

void sink(double & r1);
void sank(const double & r2);
void sunk(double && r3);

左值引用参数r1与可修改左值参数匹配；const左值引用参数r2与可修改左值参数、const左值参数和右值参数（如两个double值的和）匹配；最后，右值引用参数r3与右值匹配。r1或r3匹配的参数都与r2匹配。如果重载使用这三种参数的函数，将调用最匹配的版本。

4.1重载示例

4.2何时使用函数重载

  仅当函数基本上执行相同的任务，但使用不同形式的数据时，才应采用函数重载。

什么是名称修饰
  C++如何跟踪每一个重载函数？它给这些函数指定了私密身份。C++编译器将执行一些神奇的操作——名称修饰（name decoration）或名称矫正（name mangling），它根据函数原型中指定的形参类型对每个函数名进行加密。对原始名称进行的表明看来无意义的修饰将对参数数目和类型进行编码。添加的一组符号随函数特征标而异，而修饰时使用的约定随编译器而异。

5.函数模板

  函数模板是通用函数描述，它们使用泛型来定义函数，其中的泛型可用具体的类型替换。通过将类型作为参数传递给模板，可使编译器生成该类型的函数。模板特性有时也被称为参数化类型（parameterized types）。

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

  在标准C++98添加typename之前，C++使用class来创建模板。有大量代码是使用class开发的。在这种上下文中，这两个关键字等价。
  如果需要多个将同一种算法用于不同类型的函数，请使用模板。如果不考虑向后兼容问题，并愿意键入较长的单词，请声名类型参数时，使用typename。
  注意，函数模板不能缩短可执行程序。最终仍将多个独立的函数定义，就像手工定义了这些函数一样。最终的代码不包含任何模板，而只包含了为程序生成的实际函数。

5.1重载的模板

template <typename T>
void swap(T &a, T &b);template <typename T>
void swap(T *a, T *b, int n);

5.2模板的局限性

  编写的模板函数很可能无法处理某些类型。例如，将两个包含位置坐标的结构相加是无意义的。一种解决方案是，C++允许重载运算符。另一种是，为特定类型提供具体化的模板定义。

5.3显式具体化

  显式具体化（explicit specialization），其中包含所需的代码。当编译器找到与函数调用匹配的具体化定义时，将使用该定义，而不再寻找模板。具体化机制随着C++演变而不断变化。

1. 第三代具体化（ISO/ANSI C++标准）
     C++98选择了下面的方法：

• 对于给定的函数名，可以有非模板函数、模板函数和显式具体化模板函数以及它们的重载版本。
• 显式具体化的原型和定义应以template<>打头，并通过名称来指出类型。
• 具体化优先于常规模板，而非模板函数优先于具体化和常规模板。

void swap(job &a, job &b); //非模板
template<typename T>
void swap(T &a, T &b); //模板
template<> void swap<job>(job &a, job &b); //显式具体化，<job>是可选的，也可以写为：
template<> void swap(job &a, job &b); 

2. 显式具体化示例

5.4实例化和具体化

  在代码中包含函数模板本身并不会生成函数定义，它只是一个用于生成函数定义的方案。编译器使用模板为特定类型生成函数定义时，得到的是模板实例（instantiation）。现在C++还允许显式实例化（explicit instantiation）。这意味着可以直接命令编译器创建特定的实例。

template void swap<int>(int, int);//显式实例化
template<> void swap<int>(int  &, int &);//显式具体化
template<> void swap(int  &, int &);//显式具体化

  区别在于，显式具体化的声明的意思是“不要使用swap()模板来生成函数定义，而应使用专门为int类型显式定义的函数定义。”这些原型必须有自己的函数定义。具体化声明在template后面包含<>，而显式实例化没有。显式实例化实现了编译器看到声明后，将使用模板生成一个实例。
  试图在同一个文件（或转换单元）使用同一种类型的显示实例和显式具体化将出错。
  还可以使用函数来创建显示实例化

template<typename T>
T Add(T a, T b)
{return (a + b);
}
int m = 6;
double x = 10.2;
cout << Add<double>(x, m) << endl; //显式实例化

  隐式实例化、显式实例化和显式具体化都统称为具体化。

5.5编译器选择使用哪个函数版本

  对于函数重载、函数模板和函数模板重载，C++需要一个良好的决策来决定为函数调用使用哪一个定义，这个过程称为重载解析（overloading resolution）。

• 第1步：创建候选函数列表。
• 第2步：使用候选函数列表创建可行函数列表。
• 第3步：确定是否有最佳的可行函数。

  编译器决定最佳到最差顺序如下：
1. 完全匹配，但常规函数优于模板。
2. 提升转换（如float自动转换为double）
3. 标准转换（如int转换为char）
4. 用户定义的转换（如类声明中定义的转换）

1. 完全匹配与最佳匹配
     进行完全匹配时，C++允许某些“无关紧要的转换”。
   
     有时候，即使两个函数都完全匹配，仍可完成函数解析。首先，指向非const数据的指针和引用优先与非const指针和引用参数匹配。然而，const和非const之间的区别只适用于指针和引用指向的数据。一个完全匹配优于另一个的另一种情况是，其中一个是非模板函数，而另一个不是。在这种情况下，非模板函数将优先于模板函数。如果两个完全匹配的函数都是模板函数，则较具体的模板函数优先。
     术语“最具体（most specialized）”并不一定意味着显式具体化，而是指编译器推断使用哪种类型执行的转换最少。

template <class Type> void recycle(Type t); //#1
template <class Type> void recycle(Type * t); //#2struct blot {int a; char b[10];};
blot ink = {25, "spots"};
...
recycle(&ink);

  在这两种模板函数中，第一种更具体，因为在生成过程中，它需要转换的更少。用于找出最具体的模板的规则被称为函数模板的部分排序规则（partial ordering rules）。
2. 部分排序规则示例
3. 自己选择
4. 多个参数的函数

5.6模板函数的发展

1. 是什么类型

template<class T1, class T2>
void ft(T1 x, T2 y)
{...?type? xpy = x + y;...
}

2. 关键字decltype(C++11)

int x;
decltype(x) y; //make y the same type as x
decltype(x + y) xpy; // make xpy the same type as x + y
xpy = x + y;
//合二为一
decltype(x + y) xpy = x + y;

  为确定类型，编译器必须遍历一个核对表。假设有如下声明：
decltype(expression) var;
  核对表的简化版：
  第一步：如果expression是一个没有用括号括起来的标识符，则var的类型与标识符的类型相同，包括const等限定符。
  第二步：如果expression是一个函数调用，则var类型与函数的返回类型相同。并不会实际调用函数，通过查看原型来获悉返回类型。
  第三步：如果expression是一个左值，则var为指向其类型的引用。
  第四步：如果前面的条件都不满足，则var的类型与expression的类型相同。
  如果需要多次使用，可以结合typedef和decltype，typedef decltype(x + y) xytype;。
3. 另一种函数声明语法（C++后置返回类型）

template<class T1, class T2>
?type? gt(T1 x, T2 y)
{...return x + y;...
}

  这个问题decltype解决不了。新增语法：
double h(int x, float y);
auto h(int x, float y) -> double;
上面可以变为：

template<class T1, class T2>
auto gt(T1 x, T2 y) -> decltype(x + y)
{...return x + y;...
}