• 【C++】《C++ Primer》第六章 知识点总结

    目录

    6.1 函数基础

    静态局部对象 static类型

    编程习惯！

    6.2 参数传递

    编程习惯！

    const实参和形参

    main函数的形参

    数组作为参数

    6.3 返回类型和return语句

    错误的return

    尾置返回类型

    6.4 函数重载

    重载和const形参

    const_cast与重载

    作用域对重载的影响

    6.5 特殊用途

    内联函数inline

    6.7 函数指针

    概念

    写法和用法

    函数自动转为函数指针

    再看decltype

    附：部分习题答案

    6.1 函数基础

    静态局部对象 static类型

    用static声明后，变量的生命周期就是：从变量创建到程序结束。

    注：static类型变量默认初始化为0

    编程习惯！

    关于函数的声明和定义：

    小结：函数应该在头文件中声明，在源文件中定义。

    附：声明和定义的区别

    6.2 参数传递

    编程习惯！

    关于引用传递的参数类型：const型

    const实参和形参

    函数不会改变的形参如果不是const类型，则会有很多限制！

    • 被误认为这个参数是可以修改的！
    • 极大限制了函数所能接受的实参类型：
    1. void test1(int& a) // 非const
    2. {
    3. 	cout << a << endl;
    4. }
    5.  
    6. void test2(const int& a) // 非const
    7. {
    8. 	cout << a << endl;
    9. }
    10.  
    11. void test()
    12. {
    13. 	test1(10); // 错误！因为不能用字面值和非const引用绑定！
    14.     test2(10); // 正确！因为test2的参数是const型
    15.  
    16.     const int a = 10;
    17.     test1(a); // 错误！因为不能用const变量和非const引用绑定！
    18. 	test2(a); // 正确！因为都是const
    19.     
    20. }

    因此，可以发现，如果函数的形参只是int&，那么只有int型的实参才能与之绑定；如果是const int&，那么字面值、int型、const int型都可以与之绑定。

    main函数的形参

    数组作为参数

    两个特性：

    • 不允许拷贝数组 --> 无法值传递，只能引用传递
    • 使用数组的时候，会转为指针 --> 传一个数组，实际上传的是首元素指针

    标准库规范：传递指向首元素和尾元素的指针

    例子：

    1. int &test1(int *a, int index) // 返回引用, 第一个参数是数组首元素的地址
    2. {
    3. 	return a[index]; // 返回第index个元素的引用
    4. }
    5.  
    6. void test()
    7. {
    8. 	int a [] = {1,2,3,4,5};
    9.  
    10. 	for (auto i : a)
    11. 	{
    12. 		cout << i << " ";
    13. 	}
    14. 	cout << endl;
    15.     
    16. 	test1(a, 1) = 9; // 传入数组a,但会自动转为a[0]的地址; 因为左边是一个引用,因此可作为左值,因此可以直接赋值
    17. 	for (auto i : a)
    18. 	{
    19. 		cout << i << " ";
    20. 	}
    21. }

    6.3 返回类型和return语句

    错误的return

    尾置返回类型

    记号：->

    1. string a = "wind";
    2.  
    3. auto test(int *b) -> decltype(a) // auto的类型，就是根据decltype(a)的返回类型得到
    4. {
    5. 	return a;
    6. }
    7.  
    8. int main()
    9. {
    10. 	int b[] = { 1,2,3,4 };
    11. 	auto c = test(b);
    12. 	cout << c;
    13.  
    14. 	return 0;
    15. }

    下面三个函数等价：

    1. // 结合decltype，依据模板参数推导返回类型 
    2. template<typename ArgType1, typename ArgType2>
    3. auto Func1(ArgType1& a, ArgType2& b) -> decltype(a + b) 
    4. { 
    5.     return (a + b);
    6. }
    7.  
    8. // 在C++14中可省略箭头返回值部分，直接将函数返回类型设置为auto 
    9. template<typename ArgType1, typename ArgType2>
    10. auto Func2(ArgType1& a, ArgType2& b)
    11. { 
    12.     return (a + b);
    13. }
    14.  
    15. // 也可以直接将返回类型定义为 decltype(auto) 
    16. template<typename ArgType1, typename ArgType2>
    17. decltype(auto) Func3(ArgType1& a, ArgType2& b)
    18. {
    19.     return (a + b);
    20. }

    6.4 函数重载

    重载和const形参

    只要记住：只有引用和指针作为形参，才可以重载！否则，都不行！

    并且，会根据传入的顶层const类型去选择使用哪个重载函数:

    1. // 正确
    2. void test(int& i)
    3. {
    4. 	cout << " 1 --- " << i << endl;
    5. }
    6.  
    7. void test(const int& i)
    8. {
    9. 	cout << " 2 --- " << i << endl;
    10. }
    11.  
    12. // 错误
    13. void test1(int i)
    14. {
    15. 	cout << " 1 --- " << i << endl;
    16. }
    17.  
    18. void test1(const int i)
    19. {
    20. 	cout << " 2 --- " << i << endl;
    21. }
    22.  
    23. int main()
    24. {
    25. 	const int a = 10;
    26. 	test(a); // a是const，因此选择void test(const int& i), 输出 2 --- 10
    27.  
    28. 	return 0;
    29. }

    const_cast与重载

    const_cast常用在函数重载中！主要作用是：const型和非const型的相互转换。

    使用的初衷：通常不希望修改传入的string，因此形参被返回类型都被定义为const，然而有时候需要返回一个非const的string，因此就需要用const_cast过渡一下。

    1. string &test(const string &s1, const string &s2) // 错误，因为传入是const，返回必须是const
    2. {
    3. 	return s1.size() > s2.size() ? s1 : s2;
    4. }
    5. 正确：
    6. const string &test(const string &s1, const string &s2)
    7. {...}
    8.  
    9. int main()
    10. {
    11. 	string s1 = "wind", s2 = "wind1";
    12. 	string &s = test1(s1, s2); // 错误，因为test返回的是const，因此必须是const型接收
    13.     const string &s = test1(s1, s2); // 正确
    14. 	cout << s;
    15. 	return 0;
    16. }

    我们不希望修改s1和s2，因此test()要以const类型传入；然而我们希望第13行的s是可以修改的，但又必须用const string去接收，此时就不好办了。因此，要用const_cast过渡一下：

    1. const string &test(const string &s1, const string &s2)
    2. {
    3. 	return s1.size() > s2.size() ? s1 : s2;
    4. }
    5.  
    6. string& test1(string& s1, string& s2)
    7. {
    8. 	auto& r = test(const_cast<const string&>(s1), const_cast<const string&>(s2));
    9. 	return const_cast(r);
    10. }
    11.  
    12. int main()
    13. {
    14. 	string s1 = "wind", s2 = "wind1";
    15.  
    16. 	string &s = test1(s1, s2);
    17. 	cout << s;
    18. 	return 0;
    19. }

    第8行，用先用const_cast把非const的s1、s2转为const，调用test()，用一个const string &r去接收，然后再用const_cast把const的r转为非const的r。

    作用域对重载的影响

    一句话总结：如果在函数内层作用域中对函数做了重载，那么就会忽略所有函数外的函数重载。

    只有把重载函数放在一个作用域中（例如都在函数外或函数内），才不会被忽略：

    6.5 特殊用途

    内联函数inline

    主要作用：很多条件判断语句可以通过写一个小的函数去等价表示，这样更加清晰明了，也便于后期修改；然而函数调用是需要占用一定资源的（运行更慢），因此内联函数就用来解决这个问题。

    关键字：inline

    定义内联函数：

    调用：

    以上表面，对于较大的函数（比如有一百行），即使声明为inline，但编译器也可能不会当做内联函数使用，不然更费时间。

    注：对于inline函数和constexpr函数，通常把声明和定义放在头文件中，因为这两个函数在程序中需要被多次定义，而这些定义必须一致！

    6.7 函数指针

    概念

    顾名思义，就是指向函数的指针，这个指针可以代替函数来使用。

    写法和用法

    声明：

    类型 (*指针名称)(形参);

    例如：

    1. const string& compare(const string& s1, const string& s2)
    2. {
    3. 	return s1.size() > s2.size() ? s1 : s2;
    4. }
    5.  
    6. void test()
    7. {
    8. 	const string& (*p)(const string& s1, const string& s2);
    9. 	p = compare;
    10.  
    11. 	cout << p << endl << &compare << endl; // 输出相同
    12.  
    13. 	string b1 = p("wind", "wind1");
    14. 	cout << b1 << endl;
    15. }

    第1行，是一个函数；

    第8-9行，就是定义一个函数指针p，指向第1行的函数；

    注意：函数指针的返回类型、形参必须和函数定义保持一致

    函数： const string& compare(const string& s1, const string& s2)

    函数指针： const string& (*p)(const string& s1, const string& s2);

    指针指向函数：p = compare;

    第13行，使用函数指针p，代替直接调用函数compare()

    注1：函数指针可以初始化为0或nullptr（因为本质上就是指针，遵循指针的初始化原则）

    注2：重载函数指针时，必须清晰界定选用哪个函数，包括形参和返回类型：

    函数自动转为函数指针

    再看decltype

    decltype只会返回类型，不会做任何数据转换！！因此很多时候需要手动转换！例如：

    函数指针那里：

    1. const string& compare(const string& s1, const string& s2)
    2. {
    3. 	return s1.size() > s2.size() ? s1 : s2;
    4. }
    5.  
    6. void test()
    7. {
    8. 	const string& (*p)(const string& s1, const string& s2);
    9. 	p1 = compare;
    10.  
    11. 	string b1 = p1("wind", "wind1");
    12. 	cout << b1 << endl;
    13.  
    14. 	decltype(compare) *p2 = p1; // 重点在这里
    15. 	cout << &p2 << endl << &p1 << endl; // 地址不一样，不是同一个指针
    16.  
    17. 	string b2 = p2("wind", "wind1");
    18. 	cout << b2 << endl;
    19. }

    第14行，decltype(compare)返回的是一个函数类型，因此需要加上*才能得到指针

    附：部分习题答案

    练习6-10

    1. #include 
    2. #define _CRT_SECURE_NO_DEPRECATE
    3. using namespace std;
    4. #include 
    5. #include 
    6.  
    7. void test1(int* a, int* b)
    8. {
    9. 	int temp;
    10. 	temp = *a;
    11. 	*a = *b;
    12. 	*b = temp;
    13. }
    14.  
    15.  
    16. void test()
    17. {
    18. 	int a = 10, b = 20;
    19. 	test1(&a, &b);
    20. 	cout << a << endl << b << endl;
    21.  
    22.  
    23. }
    24.  
    25.  
    26. int main()
    27. {
    28. 	test();
    29.  
    30. 	return 0;
    31. }

    练习6-12

    1. #include 
    2. #define _CRT_SECURE_NO_DEPRECATE
    3. using namespace std;
    4. #include 
    5. #include 
    6.  
    7. void test1(int& a, int& b)
    8. {
    9. 	int temp;
    10. 	temp = a;
    11. 	a = b;
    12. 	b = temp;
    13. }
    14.  
    15.  
    16. void test()
    17. {
    18. 	int a = 10, b = 20;
    19. 	test1(a, b);
    20. 	cout << a << endl << b << endl;
    21.  
    22.  
    23. }
    24.  
    25.  
    26. int main()
    27. {
    28. 	test();
    29.  
    30. 	return 0;
    31. }

    练习6-33

    1. #include 
    2. #define _CRT_SECURE_NO_DEPRECATE
    3. using namespace std;
    4. #include 
    5. #include 
    6.  
    7. // 我的答案 -- 写复杂了
    8. vector<int>::iterator test1(vector<int>v, vector<int>::iterator begin, vector<int>::iterator end)
    9. {
    10. 	if (begin + 1 == end)
    11. 	{
    12. 		cout << *begin << endl;
    13. 		return begin;
    14. 	}
    15. 	cout << *begin << endl;
    16. 	return test1(v, begin + 1, end);
    17.  
    18. }
    19.  
    20. // 参考答案
    21. void print(vector<int>v, int index)
    22. {
    23. 	int size = v.size();
    24. 	if (index != size)
    25. 	{
    26. 		cout << v[index++] << endl;
    27. 		print(v, index);
    28. 	}
    29. }
    30.  
    31. void test()
    32. {
    33. 	vector<int>v;
    34. 	for (int i = 0; i < 10; ++i)
    35. 	{
    36. 		v.push_back(i);
    37. 	}
    38.  
    39. 	/// 调用我的答案
    40. 	//vector::iterator begin = v.begin();
    41. 	//vector::iterator end = v.end();
    42. 	//vector::iterator iter = test1(v, begin, end);
    43.  
    44. 	/// 调用参考答案
    45. 	int index = 0;
    46. 	print(v, index);
    47.  
    48. }
    49.  
    50. int main()
    51. {
    52. 	test();
    53.  
    54. 	return 0;
    55. }

    练习6-36

    1. #include 
    2. #define _CRT_SECURE_NO_DEPRECATE
    3. using namespace std;
    4. #include 
    5. #include 
    6.  
    7. // 6.36
    8. string(&func())[10];
    9.  
    10. // 6.37
    11. // 类型别名
    12. typedef string arrT[10];
    13. using arrT1 = string[10];
    14. arrT& func();
    15. arrT1& func();
    16.  
    17. // 尾置返回类型
    18. auto func()->string(&)[10];
    19.  
    20. // decltype关键字
    21. string str[10];
    22. decltype(str)& func();
    23.  
    24.  
    25. int main()
    26. {
    27. 	return 0;
    28. }

    练习6-54

    1. #include 
    2. #define _CRT_SECURE_NO_DEPRECATE
    3. using namespace std;
    4. #include 
    5. #include 
    6.  
    7. void test()
    8. {
    9. 	// 函数的声明
    10. 	int func(int, int);
    11.  
    12. 	// vector对象的声明
    13. 	vector< decltype(func)* >v;
    14.  
    15. }
    16.  
    17. int main()
    18. {
    19. 	return 0;
    20. }

    练习6-55和6-56

    1. #include 
    2. #define _CRT_SECURE_NO_DEPRECATE
    3. using namespace std;
    4. #include 
    5. #include 
    6.  
    7. int func1(int a, int b)
    8. {
    9. 	return a + b;
    10. }
    11.  
    12. int func2(int a, int b)
    13. {
    14. 	return a - b;
    15. }
    16.  
    17. void test()
    18. {
    19.  
    20. 	vector< decltype(func1)* >v;
    21. 	decltype(func1)* p1 = func1;
    22. 	decltype(func1)* p2 = func2;
    23.  
    24. 	v = { p1, p2 };
    25.  
    26. 	for (auto i : v)
    27. 	{
    28. 		cout << (*i)(1, 1) << endl;
    29. 	}
    30.  
    31. }
    32.  
    33. int main()
    34. {
    35. 	test();
    36.  
    37. 	return 0;
    38. }

  • 相关阅读:
    js制作动态表单
    MTK MFNR
    C++基本知识（二）---函数重载、引用、内联函数、auto关键字
    Android开发常见问题收集（长期更新）
    CAS和AOuth2的比较
    产品设计如何提升客户体验？
    IT项目经理必备的五种能力
    C++11实现的数据库连接池
    elasticsearch 7.X全部版本的新特性与重大变化
    Sql中having和where的区别
  • 原文地址：https://blog.csdn.net/Wind_2028/article/details/127634633