这章的重点是内联函数，引用，左右值是什么等？
还有个大重点函数模板，也就是所谓的泛式
第八章 函数探幽
复习后解决下面的问题：
问：什么情况下编译器可能不会将一个函数处理为内联函数？
问：内联函数和宏有什么区别？
问： 引用和指针有什么区别？
问: 为什么const在函数重载中很重要？
问: 返回类型是否影响函数重载？
问：什么是左右值？
问：函数模板和普通函数有什么不同？
问：在什么情况下使用显式具体化？
内联函数；
总结：
-
内联函数是C++为提高程序运行速度所做的一项改进。与常规函数的区别不在于编写方式，而在于C++编译器如何将它们组合到程序中。 -
内联函数的编译代码与其他程序代码“内联”起来了。编译器将使用相应的函数代码替换函数调用。对于内联代码，程序无需跳到另一个位置处执行代码，再跳回来。
-
使用内联函数可以节省处理函数调用机制的时间，特别是对于执行时间较短的代码段，内联函数可以显著提高效率。
-
要使用这项特性，必须在函数声明和定义前加上关键字
inline。 -
程序员请求将函数作为内联函数时，编译器并不一定会满足这种要求。例如当函数过大或函数调用了自己（内联函数不能递归）时。
-
尽管程序没有提供独立的原型，但C++原型特性仍在起作用。这是因为在函数首次使用前出现的整个函数定义充当了原型。
// inline.cpp -- using an inline function
#include <iostream>
// an inline function definition
inline double square(double x) { return x * x; }
int main()
{
using namespace std;
double a, b;
double c = 13.0;
a = square(5.0);
b = square(4.5 + 7.5); // can pass expressions
cout << "a = " << a << ", b = " << b << "\n";
cout << "c = " << c;
cout << ", c squared = " << square(c++) << "\n";
cout << "Now c = " << c << "\n";
return 0;
}
点击前往详细问题
7. 内联功能远远胜过C语言的宏定义。宏是通过文本替换来实现的，并且宏不能按值传递。
#define SQUARE(X) X*X // 宏定义
这并不是通过传递参数实现的，而是通过文本替换来实现的——X是“参数”的符号标记。
a = SQUARE(5.0); is replaced by a = 5.0*5.0;
b = SQUARE(4.5 + 7.5); is replaced by b = 4.5 + 7.5 * 4.5 + 7.5;
d = SQUARE(c++); is replaced by d = c++*c++;
上述示例只有第一个能正常工作。可以通过使用括号来进行改进：
#define SQUARE(X) ((X)*(X))
但仍然存在这样的问题，即宏不能按值传递。即使使用新的定义，SQUARE（C++）仍将c递增两次
问题：
-
什么是内联函数？
- 内联函数是C++为提高程序运行速度所做的一项改进，其编译代码与其他程序代码直接结合在一起。对于内联代码，程序无需跳转到另一个位置执行代码再返回。
-
如何声明一个内联函数？
- 在函数声明或定义前加上关键字inline。
-
什么情况下编译器可能不会将一个函数处理为内联函数？
- 当函数过大或函数调用了自己（内联函数不能递归）时，编译器可能不会将其处理成内联函数。
-
内联函数和宏有什么区别？
- 内联函数是通过替换函数调用来实现的，并且可以按值传递参数。而宏是通过文本替换来实现的，并且不能按值传递。
引用变量 （1）；
总结：
-
C++使用
&符号来声明引用。例如，要将rodents作为rats变量的别名，可以这样做：int & rodents = rats; 其中，&不是地址运算符，而是类型标识符的一部分。 -
引用的值和地址与其引用的变量完全相同，像一个别名。
-
必须在声明引用时将其初始化，不能像指针那样，先声明，再赋值。
4. 点击前往详细问题 一旦引用被初始化为对某个变量的引用，就不能改变为引用另一个变量。即使试图通过指针改变引用的关联性，也不会成功。
引用更接近const指针，必须在创建时进行初始化，一旦与某个变量关联起来，就将一直效忠于它。也就是说：
int & rodents = rats;
实际上是下述代码的伪装表示：
int * const pr = &rats;
问题：
-
什么是C++中的引用？
- 在C++中，引用是一个已存在变量的别名，具有与原变量相同的值和地址。
-
如何声明和初始化引用？
- 在声明引用时必须进行初始化，例如：int & rodents = rats;
-
引用是否可以改变为引用另一个变量？
- 不可以，一旦引用被初始化为对某个变量的引用，它就不能改变为引用另一个变量。
-
引用和指针有什么区别？
- 主要的区别是，引用必须在声明时进行初始化，并且一旦被初始化后就不能改变为引用另一个变量，它更接近const指针。而指针可以在声明后任何时间进行初始化和改变其指向的对象。
引用变量 （2）；
总结：
-
当函数的参数为
引用类型时，函数对其进行的任何修改都会直接反映在原变量上。 -
如果不希望函数修改传递给它的信息，同时又想使用引用，则应使用
常量引用。如：double refcube(const double &ra); -
在C++中，如果实参与引用参数不匹配，C++将生成
临时变量。当前，仅当参数为const引用时，C++才允许这样做。 -
应尽可能将引用形参声明为
const，这可以避免无意中修改数据的编程错误、使函数能够处理const和非const实参，以及使函数能够正确生成并使用临时变量。 -
C++11新增了另一种引用——
右值引用（rvalue reference）。这种引用可指向右值，是使用&&声明的，主要目的是让库设计人员能够提供有些操作的更有效实现。
问题：
-
函数参数为引用类型时，函数对其进行的修改会如何反映？
- 函数对引用类型参数的修改会直接反映在原变量上。
-
如何防止函数修改传递给它的信息，同时又使用引用？
- 可以通过使用常量引用来防止函数修改传递给它的信息。例如：double refcube(const double &ra);
-
什么情况下C++会生成临时变量？
- 如果实参与引用参数不匹配，C++将生成临时变量。当前，仅当参数为const引用时，C++才允许这样做。
-
为什么应尽可能将引用形参声明为const？
- 将引用形参声明为const可以避免无意中修改数据的编程错误、使函数能够处理const和非const实参，以及使函数能够正确生成并使用临时变量。
-
什么是右值引用？其主要用途是什么？
- 右值引用是C++11新增的一种引用类型，可以指向右值，使用&&声明。其主要目的是让库设计人员能够提供有些操作的更有效实现。
- 用途
这里主要介绍右引用的左右，其实就是直接将右值地址赋值给另外一个对象，相比于值传递（尤其对于临时变量），少了数据的创建和复制，尤其在大数据转移过程中效率看得见。
左右值
点击前往详细问题
左值引用和右值引用
左值引用：引用一个对象；左值引用在汇编层面其实和普通的指针是一样的；定义引用变量必须初始化，因为引用其实就是一个别名，需要告诉编译器定义的是谁的引用。
右值引用：就是必须绑定到右值的引用，C++11中右值引用可以实现“移动语义”，通过 && 获得右值引用。
等号两边必须是左值对应左引用，右值对应右引用。
int x = 100; // x是左值，100是右值
int & y = x; // 左值引用，y引用x
int & p1 = x * 10; // 错误，x*6是一个右值
const int & p2 = x * 10; // 正确，可以将一个const引用绑定到一个右值
int && p3 = x * 10; // 正确，右值引用
int && p4 = x; // 错误，x是一个左值
如何按引用传递函数参数；
知识点总结：
-
使用引用参数的原因：
- 允许程序员修改调用函数中的数据对象。
- 通过传递引用而不是整个数据对象，可以提高程序的运行速度，特别是在处理大型结构或类对象时。
-
什么时候使用引用、什么时候使用指针、什么时候按值传递：
- 对于使用传递的值而不作修改的函数：
- 对于小型数据对象，如内置数据类型或小型结构，应按值传递。
- 对于数组，应使用指针，并将指针声明为指向const的指针，以防止修改。
- 对于较大的结构，应使用const指针或const引用，以提高效率，避免复制结构所需的时间和空间。
- 对于类对象，应使用const引用，因为类设计的语义通常要求使用引用，这是C++新增特性的主要原因。
- 对于修改调用函数中数据的函数：
- 对于内置数据类型，应使用指针，因为这允许函数修改数据对象。
- 对于数组，只能使用指针，因为数组名被视为指向数组第一个元素的指针。
- 对于结构，可以使用引用或指针，具体取决于需要。
- 对于类对象，应使用引用，因为类对象通常按引用传递以确保操作不复制整个对象。
- 对于使用传递的值而不作修改的函数：
问题和答案：
问题 1: 为什么在处理大型结构或类对象时应使用const引用或const指针？
答案: 使用const引用或const指针可以提高程序的效率，因为它们避免了复制大型结构或类对象所需的时间和空间开销。这样，函数可以访问对象的内容而不进行复制。
问题 2: 什么时候应该使用指针而不是引用？
答案: 指针应该在需要修改数据对象的函数中使用，因为指针允许函数修改数据。对于内置数据类型和数组，通常使用指针。
问题 3: 为什么在C++中传递类对象参数的标准方式是按引用传递？
答案: 传递类对象参数按引用传递是C++中的标准方式，因为类设计的语义通常要求使用引用。这确保了在函数中操作类对象时不会复制整个对象，提高了效率。
问题 4: 为什么对于基本类型如int，cin使用引用，而不是按值传递？
答案: cin使用引用是为了允许函数修改输入的基本类型数据，而不是传递它们的副本。这使得代码更加清晰，例如，可以使用cin >> n而不是cin >> &n。
默认参数；
重要知识点总结：
-
默认参数是指在函数定义中为参数提供一个默认值，使得在函数调用时可以选择性地省略某些参数，从而提高函数的灵活性。
-
默认参数必须在函数原型中指定，并通过赋值来初始化参数的默认值。
-
默认参数的设置必须从右向左进行，即必须为右边的参数提供默认值，不能仅为左边的参数提供默认值。
-
函数调用时，实参按从左到右的顺序依次赋给对应的形参，不能跳过任何参数。
-
默认参数并非重大编程突破，但提供了一种便捷的方式，可以减少函数的重载数量，特别在设计类时很有用。
重要问题和答案：
问题 1: 什么是默认参数？为什么它们对函数的灵活性有所帮助？
答案: 默认参数是指在函数定义中为参数提供默认值，允许在函数调用时省略某些参数。这提高了函数的灵活性，使得函数可以有更多的用法，而不必为每种用法都创建一个新的函数重载。
问题 2: 如何在函数原型中指定默认参数？
答案: 默认参数通过在函数原型中为参数赋值来指定。例如，int add(int a, int b = 0) 中的b = 0 就是一个默认参数。
问题 3: 默认参数的设置顺序是什么？为什么必须从右向左进行？
答案: 默认参数的设置顺序是从右向左的，这意味着必须为右边的参数提供默认值。这是因为在函数调用时，实参会按照从左到右的顺序依次赋给形参，而不能跳过参数。所以，左边的参数可以省略，但右边的参数不能省略。
问题 4: 为什么默认参数对于函数重载有用？
答案: 默认参数可以减少函数的重载数量，因为可以为一个函数提供多个默认参数值，从而覆盖不同的用例，而无需创建多个函数重载来处理不同的参数组合。这可以使代码更清晰和简洁。
函数重载；
知识点总结：
- 函数重载是C++中的一种特性，允许您定义多个同名函数，但它们的参数列表（特征标）必须不同。
- 特征标由参数的数量、类型和顺序组成。
- 当调用重载函数时，编译器会根据提供的参数来选择匹配的函数。
- 如果没有找到与参数匹配的重载函数，编译器将尝试进行标准类型转换以匹配最接近的函数。
- const修饰符在函数重载中起着重要的作用，允许区分对const和非const参数的调用。
- 返回类型不会影响函数重载，仅特征标（参数列表）不同的函数才能重载。
重要问题和答案：
问题 1: 什么是函数重载，为什么它在C++中很有用？
答案：函数重载是指在同一个作用域内定义多个同名函数，但它们的参数列表必须不同。这使得您可以使用相同的函数名执行多种不同的操作，根据参数的不同选择合适的函数。这提高了代码的可读性和可维护性，同时提供了更灵活的函数调用方式。
问题 2: 什么是函数特征标，为何它在函数重载中如此重要？
答案：函数特征标是函数的参数列表，包括参数的数量、类型和顺序。在函数重载中，编译器使用特征标来确定要调用的函数版本。如果两个函数的特征标相同，它们不能同时存在，因此特征标的唯一性是区分不同重载版本的关键。
问题 3: 如何区分重载函数中的最佳匹配？
答案：编译器会尝试选择最匹配的重载函数，首先考虑完全匹配参数的函数，然后考虑进行标准类型转换匹配的函数。如果多个函数都有相同级别的匹配，编译器将报告二义性错误，因为无法确定使用哪个函数。
问题 4: 为什么const在函数重载中很重要？
答案：const关键字在函数重载中用于区分对const和非const参数的调用。这允许您编写不同行为的函数版本，以适应不同类型的参数。在C++中，const参数是常量，而非const参数是可修改的，因此const关键字帮助编译器确定最合适的函数。
将非const值赋给const变量是合法的，但反之则是非法的
问题 5: 返回类型是否影响函数重载？
答案：不，返回类型不影响函数重载。函数的重载仅与参数列表（特征标）有关。如果两个函数具有不同的特征标，它们可以具有不同的返回类型，这是合法的。但如果特征标相同，则无法通过返回类型来区分它们。
函数模板；
引入
重要重要重要！
知识点总结：
- 函数模板是C++中的一项特性，允许定义通用的函数，使用泛型来处理不同类型的数据。
- 函数模板通过将类型作为参数传递给模板来实现，编译器根据参数类型生成具体的函数实现。
- 函数模板可以提高代码的重用性和可维护性，避免手动编写多个相似的函数。
- 在函数模板中，关键字
template用于声明模板，typename（或class）用于指定类型参数，尖括号用于包裹类型参数。
template <typename AnyType>
void Swap(AnyType &a, AnyType &b)
{
AnyType temp;
temp = a;
a = b;
b = temp;
}
- 在C++98之前，使用关键字
class来声明模板类型参数也是合法的，但现代代码中更常使用typename。 - 使用函数模板时，编译器会根据参数类型自动生成具体的函数实现。
- 函数模板的定义包括函数模板的原型和实际的函数模板定义。
- 头文件通常用于存放函数模板的定义，可以在需要使用模板的文件中包含头文件以使用模板。
重要问题和答案：
9. 什么是函数模板？函数模板有什么作用？
- 函数模板是C++中的通用函数描述，允许处理不同类型的数据。它们通过泛型来定义函数，可以根据传递的参数类型自动生成具体的函数实现。函数模板提高了代码的重用性和可维护性，避免了手动编写多个相似的函数。
- 如何定义一个函数模板？
- 要定义一个函数模板，使用
template关键字声明模板，使用typename（或class）指定类型参数，然后使用尖括号包裹类型参数。例如：template <typename T> void Swap(T &a, T &b);
- 为什么需要函数模板？有什么优点？
- 函数模板的主要优点是提高了代码的灵活性和重用性。它们允许以泛型的方式编写代码，可以处理不同类型的数据，减少了代码的冗余和错误。使用函数模板可以简化代码并提高代码的可维护性。
- 函数模板的参数类型如何自动推导？
- 函数模板的参数类型是根据传递给函数的实际参数类型进行推导的。编译器根据函数调用时传递的参数类型生成相应的函数实现。
- 函数模板和普通函数有什么不同？
- 函数模板是通用的函数描述，可以处理不同类型的数据，而普通函数通常只能处理特定类型的数据。函数模板在编译时根据参数类型生成具体的函数实现，而普通函数的参数类型是固定的。
- 如何在程序中使用函数模板？
- 要在程序中使用函数模板，只需调用模板函数即可，编译器会根据参数类型自动生成相应的函数实现。例如：
Swap(i, j);可以调用函数模板Swap来交换两个整数。
- 头文件通常用于存放函数模板的定义吗？
- 是的，通常将函数模板的定义放在头文件中，并在需要使用模板的文件中包含该头文件。这有助于模块化代码并提高代码的可维护性。
函数模板也是可以重载的
和函数模板一样
下面看列子就行
template <typename T>
void Swap(T &a, T &b)
{
T temp;
temp = a;
a = b;
b = temp;
}
template <typename T>
void Swap(T a[], T b[], int n)
{
T temp;
for (int i = 0; i < n; i++)
{
temp = a[i];
a[i] = b[i];
b[i] = temp;
}
}
函数模板具体化。
知识点总结：
- 显式具体化（explicit specialization）是C++中一种用于特殊情况的函数模板定义方式。
- 显式具体化允许为特定类型提供特定的函数实现，覆盖了通用模板函数的定义。
- 显式具体化通过在函数模板的定义前加上
template <>并指定类型来实现，例如：template <> void Swap<job>(job &j1, job &j2);。 - 显式具体化的定义优先于通用模板函数的定义，因此在特定类型的情况下，编译器将选择使用显式具体化的版本。
- 显式具体化可以用于解决特定类型的函数需求，而不影响通用模板函数的行为。
重要问题和答案：
-
什么是显式具体化（explicit specialization）？
- 显式具体化是一种C++中的函数模板定义方式，允许为特定类型提供特定的函数实现，覆盖通用模板函数的定义。
-
为什么需要显式具体化？
- 显式具体化允许在特定情况下提供自定义的函数实现，而不影响通用模板函数的行为。这在需要为特定类型编写特殊代码的情况下非常有用。
-
如何定义显式具体化？
- 显式具体化的定义以
template <>开始，然后指定类型和函数参数，例如：template <> void Swap<job>(job &j1, job &j2);。
- 显式具体化的定义以
-
显式具体化和通用模板函数的优先级如何？
- 显式具体化的定义优先于通用模板函数的定义，因此在特定类型的情况下，编译器将选择使用显式具体化的版本。
-
在什么情况下使用显式具体化？
- 显式具体化通常用于解决特定类型的函数需求，例如，当需要为某个特定结构或类型编写特殊的交换函数时。这允许在通用模板函数的基础上提供自定义实现。
你有一个函数模板
template <typename T>
void Swap(T &, T &);
这是这个函数模板的定义，功能是交换
template <typename T>
void Swap(T &a, T &b) // general version
{
T temp;
temp = a;
a = b;
b = temp;
}
假设定义了如下结构：
struct job
{
char name[40];
double salary;
int floor;
};
你怎么使用Swap去完成功能呢？，或许你可以重新定义一个函数，但这是愚蠢的，因为如果我有很多个结构，你难不成重新定义这些函数名吗？我只能说连名字都不想记。
下面就是我们显式具体化的表演时间
先使用具体化的原型
template <> void Swap<job>(job &j1, job &j2);
重新定义
template <> void Swap<job>(job &j1, job &j2) // specialization
{
double t1;
int t2;
t1 = j1.salary;
j1.salary = j2.salary;
j2.salary = t1;
t2 = j1.floor;
j1.floor = j2.floor;
j2.floor = t2;
}
完整的代码
// twoswap.cpp -- specialization overrides a template
#include <iostream>
template <typename T>
void Swap(T &a, T &b);
struct job
{
char name[40];
double salary;
int floor;
};
// explicit specialization
template <> void Swap<job>(job &j1, job &j2);
void Show(job &j);
int main()
{
using namespace std;
cout.precision(2);
cout.setf(ios::fixed, ios::floatfield);
int i = 10, j = 20;
cout << "i, j = " << i << ", " << j << ".\n";
cout << "Using compiler-generated int swapper:\n";
Swap(i,j); // generates void Swap(int &, int &)
cout << "Now i, j = " << i << ", " << j << ".\n";
job sue = {"Susan Yaffee", 73000.60, 7};
job sidney = {"Sidney Taffee", 78060.72, 9};
cout << "Before job swapping:\n";
Show(sue);
Show(sidney);
Swap(sue, sidney); // uses void Swap(job &, job &)
cout << "After job swapping:\n";
Show(sue);
Show(sidney);
// cin.get();
return 0;
}
template <typename T>
void Swap(T &a, T &b) // general version
{
T temp;
temp = a;
a = b;
b = temp;
}
// swaps just the salary and floor fields of a job structure
template <> void Swap<job>(job &j1, job &j2) // specialization
{
double t1;
int t2;
t1 = j1.salary;
j1.salary = j2.salary;
j2.salary = t1;
t2 = j1.floor;
j1.floor = j2.floor;
j2.floor = t2;
}
void Show(job &j)
{
using namespace std;
cout << j.name << ": $" << j.salary
<< " on floor " << j.floor << endl;
}
下面是该程序的输出：
i, j = 10, 20.
Using compiler-generated int swapper:
Now i, j = 20, 10.
Before job swapping:
Susan Yaffee: $73000.60 on floor 7
Sidney Taffee: $78060.72 on floor 9
After job swapping:
Susan Yaffee: $78060.72 on floor 9
Sidney Taffee: $73000.60 on floor 7
问题区
问：什么情况下编译器可能不会将一个函数处理为内联函数？
- 当函数过大或函数调用了自己（内联函数不能递归）时，编译器可能不会将其处理成内联函数。
问：内联函数和宏有什么区别？
-
内联函数是通过替换函数调用来实现的，并且可以按值传递参数。而宏是通过文本替换来实现的，并且不能按值传递。
问： 引用和指针有什么区别？
- 主要的区别是，引用必须在声明时进行初始化，并且一旦被初始化后就不能改变为引用另一个变量，它更接近const指针。而指针可以在声明后任何时间进行初始化和改变其指向的对象。
点击前往详细答案
问: 为什么const在函数重载中很重要？
- 答案：const关键字在函数重载中用于区分对const和非const参数的调用。这允许您编写不同行为的函数版本，以适应不同类型的参数。在C++中，const参数是常量，而非const参数是可修改的，因此const关键字帮助编译器确定最合适的函数。
将非const值赋给const变量是合法的，但反之则是非法的
问: 返回类型是否影响函数重载？
- 答案：不，返回类型不影响函数重载。函数的重载仅与参数列表（特征标）有关。如果两个函数具有不同的特征标，它们可以具有不同的返回类型，这是合法的。但如果特征标相同，则无法通过返回类型来区分它们。
问：什么是左右值？
问：函数模板和普通函数有什么不同？
- 函数模板是C++中的通用函数描述，允许处理不同类型的数据。它们通过泛型来定义函数，可以根据传递的参数类型自动生成具体的函数实现。函数模板提高了代码的重用性和可维护性，避免了手动编写多个相似的函数。
- 函数模板是通用的函数描述，可以处理不同类型的数据，而普通函数通常只能处理特定类型的数据。函数模板在编译时根据参数类型生成具体的函数实现，而普通函数的参数类型是固定的。
问：在什么情况下使用显式具体化？
- 显式具体化通常用于解决特定类型的函数需求，例如，当需要为某个特定结构或类型编写特殊的交换函数时。这允许在通用模板函数的基础上提供自定义实现。
扫一扫
187
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
