devbox
tf789
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

【C/C++ 13】C++11高效特性

作者：tf789 | 2024-02-06 13:08:22

赞

踩

【C/C++ 13】C++11高效特性

目录

一、初始化列表

二、auto

三、decltype

四、可变参数列表

五、lambda表达式

C++11在C++98的基础上增添了许多特性，但是同时也使得C++程序的开发变得复杂繁琐，让众多开发者苦不堪言，于是我们需要从C++11新增舔的特性中选择一些能够提高开发效率的东西进行学习和应用。

一、初始化列表

在C++98中，标准允许使用花括号{}对数组或者结构体元素进行统一的列表初始值设定，比如：

  1. struct Point
  2. {
  3.     int _x;
  4.     int _y;
  5. };
  6.  
  7. int main()
  8. {
  9.     int array1[] = { 1, 2, 3, 4, 5 };
  10.     int array2[5] = { 0 };
  11.     Point p = { 1, 2 };
  12.     return 0;
  13. }

C++11扩大了用大括号括起的列表(初始化列表)的使用范围，使其可用于所有的内置类型和用户自
定义的类型，使用初始化列表时，可添加等号(=)，也可不添加，但是这样一来，C++代码就有些显得花里胡哨了，为了和C++98更兼容，建议在对列表进行初始化时都加上等号。

但是C++11的初始化列表在new表达式中非常方便，我们只在new表达式中使用C++11初始化列表即可。

  1. #include <iostream>
  2. using namespace std;
  3.  
  4. int main()
  5. {
  6. 	int* arr1 = new int[3]{ 0 };
  7. 	int* arr2 = new int[3]{ 1, 2, 3 };
  8.  
  9. 	for (int i = 0; i < 3; ++i)
  10. 		cout << arr1[i] << ' ';
  11. 	// 0 0 0
  12.  
  13. 	cout << endl;
  14. 	for (int i = 0; i < 3; ++i)
  15. 		cout << arr2[i] << ' ';
  16. 	// 1 2 3
  17.  
  18. 	return 0;
  19. }
  1. #include <iostream>
  2. using namespace std;
  3.  
  4. int main()
  5. {
  6. 	auto il = { 10, 20, 30 };
  7. 	cout << typeid(il).name() << endl;
  8. 	// class std::initializer_list<int>
  9. 	return 0;
  10. }
  11. // std::initializer_list
  12. // This type is used to access the values in a C++ initialization list, 
  13. // which is a list of elements of type const T.
  14.  
  15. // std::initializer_list一般是作为构造函数的参数。
  16. // C++11对STL中的不少容器就增加std::initializer_list作为参数的构造函数，这样初始化容器对象就更方便了。
  17. // 也可以作为operator = 的参数，这样就可以用大括号赋值。
  1. #include <iostream>
  2. #include <vector>
  3. using namespace std;
  4.  
  5. int main()
  6. {
  7. 	// 初始化列表对STL容器初始化构造
  8. 	vector<int> arr = { 1, 2, 3 };
  9.  
  10. 	for (int i = 0; i < arr.size(); ++i)
  11. 		cout << arr[i] << ' ';
  12. 	// 1 2 3
  13.  
  14. 	return 0;
  15. }

二、auto

C++11中 auto 用于实现自动类型推断，常应用于迭代器和范围for循环中。

  1. #include <iostream>
  2. #include <map>
  3. using namespace std;
  4.  
  5. int main()
  6. {
  7. 	int i = 10;
  8. 	auto p = &i;
  9. 	cout << typeid(p).name() << endl;	// int *
  10. 	
  11. 	map<string, string> dict = { {"sort", "排序"}, {"insert", "插入"}, {"delete", "删除"} };
  12. 	//map<string, string>::iterator it = dict.begin();
  13. 	auto it = dict.begin();		// 迭代器类型
  14. 	while (it != dict.end())
  15. 	{
  16. 		cout << "<" << it->first << ", " << it->second << ">" << ' ';	// delete, 删除
  17. 		++it;
  18. 	}
  19. 	cout << endl;
  20.  
  21.     // 范围for循环
  22. 	for (const auto& e : dict)
  23. 		cout << "<" << e.first << ", " << e.second << ">" << ' ';	// delete, 删除
  24.  
  25.  
  26. 	return 0;
  27. }

三、decltype

关键字decltype将变量的类型声明为表达式指定的类型。

  1. #define _CRT_SECURE_NO_WARNINGS 1
  2. #include <iostream>
  3. using namespace std;
  4.  
  5. template<class T1, class T2>
  6. void F(T1 x, T2 y)
  7. {
  8. 	decltype(x * y) ret;
  9. 	cout << typeid(ret).name() << endl;
  10. }
  11.  
  12. int main()
  13. {
  14. 	const int x = 1;
  15. 	double y = 2.5;
  16.  
  17. 	decltype(x * y) ret;
  18. 	decltype(&x) p;
  19. 	cout << typeid(ret).name() << endl;		// double
  20. 	cout << typeid(p).name() << endl;		// int const *
  21.  
  22. 	F(1, 'a');		// int
  23.  
  24. 	return 0;
  25. }

四、可变参数列表

C++11的可变参数模板能够创建可以接受可变参数的函数模板和类模板，相比于C++98类模板只能含固定数量的模版参数，可变模版参数无疑是一个巨大的改进。

  1. // Args是一个模板参数包，args是一个函数形参参数包
  2. // 声明一个参数包Args...args，这个参数包中可以包含0到任意个模板参数。
  3. template <class ...Args>
  4. void ShowList(Args... args)
  5. {}
  6.  
  7. /*
  8. 上面的参数args前面有省略号，所以它就是一个可变模版参数，我们把带省略号的参数称为“参数包”，
  9. 它里面包含了0到N（N >= 0）个模版参数。我们无法直接获取参数包args中的每个参数的，
  10. 只能通过展开参数包的方式来获取参数包中的每个参数，
  11. 这是使用可变模版参数的一个主要特点，也是最大的难点，即如何展开可变模版参数。
  12. 由于语法不支持使用args[i]这样方式获取可变参数，所以我们的用一些奇招来一一获取参数包的值。
  13. */
  1. #define _CRT_SECURE_NO_WARNINGS 1
  2. #include <iostream>
  3. using namespace std;
  4.  
  5. // 递归方式展开参数包
  6. template<class T>
  7. void ShowList(const T& value)
  8. {
  9. 	cout << value << endl;
  10. }
  11.  
  12. template <class T, class ...Args>
  13. void ShowList(T value, Args... args)
  14. {
  15. 	cout << value << " ";
  16. 	ShowList(args...);
  17. }
  18.  
  19. int main()
  20. {
  21. 	ShowList(1);
  22. 	ShowList(1, 'a');
  23. 	ShowList(1, 'a', string("test"));
  24.  
  25. 	return 0;
  26. }
  1. #define _CRT_SECURE_NO_WARNINGS 1
  2. #include <iostream>
  3. using namespace std;
  4.  
  5. // 逗号表达式展开参数包
  6. template<class T>
  7. void PrintArgs(T t)
  8. {
  9. 	cout << t << ' ';
  10. }
  11.  
  12. template <class ...Args>
  13. void ShowList(Args... args)
  14. {
  15. 	int arr[] = { (PrintArgs(args), 0)... };
  16. 	cout << endl;
  17. }
  18.  
  19. int main()
  20. {
  21. 	ShowList(1);
  22. 	ShowList(1, 'a');
  23. 	ShowList(1, 'a', string("test"));
  24.  
  25. 	return 0;
  26. }
  27.  
  28. /*
  29. 	这种展开参数包的方式，不需要通过递归终止函数，是直接在expand函数体中展开的，
  30. 	PrintArg不是一个递归终止函数，只是一个处理参数包中每一个参数的函数。
  31. 	这种就地展开参数包的方式实现的关键是逗号表达式，我们知道逗号表达式会按顺序执行逗号前面的表达式。
  32. 	expand函数中的逗号表达式：(printarg(args), 0)，也是按照这个执行顺序，
  33. 	先执行PrintArg(args)，再得到逗号表达式的结果0。
  34. 	同时还通过初始化列表来初始化一个变长数组，
  35. 	{(PrintArg(args), 0)...}将会展开成((PrintArg(arg1),0), (printarg(arg2),0), (printarg(arg3),0), etc... )
  36. 	最终会创建一个元素值都为0的数组int arr[sizeof...(Args)]。
  37. 	于是逗号表达式，在创建数组的过程中会先执行逗号表达式前面的部分PrintArg(args)打印出参数，
  38. 	也就是说在构造int数组的过程中就将参数包展开了，这个数组的目的纯粹是为了在数组构造的过程展开参数包。
  39. */

五、lambda

C++11的 lambda 表达式，实际上是一个匿名函数，熟练使用 lambda 表达式，可以极大地提升编程效率。

  1. // lambda表达式语法
  2. [capture-list](parameters)mutable->return-type{statement}
  3.  
  4. // [capture-list]：捕捉列表，捕捉上下文中的变量供lambda使用
  5. // (parameters)：参数列表
  6. // mutable：取消lambda函数的默认常性，使用该修饰符时参数列表不可省略
  7. // ->return-type：返回值类型，可省略由编译器推导
  8. // {statement}：函数体，除了可以使用参数列表的变量，还可以使用捕捉到的变量

在lambda函数定义中，参数列表和返回值类型都是可选部分，而捕捉列表和函数体可以为空。

  1. #define _CRT_SECURE_NO_WARNINGS 1
  2.  
  3. #include <iostream>
  4. using namespace std;
  5.  
  6. int main()
  7. {
  8. 	// 最简单的lambda表达式
  9. 	auto func1 = [] {};
  10. 	func1();
  11.  
  12. 	// 省略参数列表，返回值由编译器推导
  13. 	int a = 3, b = 4;
  14. 	auto func2 = [=] {cout << a + b << endl; };
  15. 	func2();
  16.  
  17. 	auto func3 = [&](int c) {b = c + a; };
  18. 	func3(10);
  19. 	cout << "b = " << b << endl;
  20.  
  21. 	cout << [=, &b](int c)->int {return b += a + c; }(10) << endl;
  22.  
  23. 	auto func4 = [b](int a)mutable {b %= 10; return b + a; };
  24. 	cout << func4(5) << endl;
  25.  
  26. 	return 0;
  27. }
  28.  
  29. /*
  30. 捕获列表说明：
  31. 	1. [var]：表示值传递方式捕捉变量var
  32. 	2. [=]：表示值传递方式捕获所有父作用域中的变量(包括this)
  33. 	3. [&var]：表示引用传递捕捉变量var
  34. 	4. [&]：表示引用传递捕捉所有父作用域中的变量(包括this)
  35. 	5. [this]：表示值传递方式捕捉当前的this指针
  37. 注意：
  38. 	1. 父作用域指包含lambda函数的语句块
  39. 	2. 语法上捕捉列表可由多个捕捉项组成，并以逗号分割
  40. 	3. 捕捉列表不允许变量重复传递，否则就会导致编译错误
  41. 	4. lambda表达式之间不能相互赋值
  42. */

从原理上看，编译器对于lambda表示式的实现方式，就是将其作为仿函数实现的，而仿函数的实现原理就是对 operator() 进行重载。也就是说，如果定义了一个lambda表达式，编译器会自动生成一个类，在该类中重载了operator()。 

从代码编写角度来说，使用lambda表达式效率更高。

  1. #define _CRT_SECURE_NO_WARNINGS 1
  2.  
  3. #include <iostream>
  4. using namespace std;
  5.  
  6. class Salary
  7. {
  8. public:
  9. 	Salary(int money)
  10. 		: _money(money)
  11. 	{}
  12.  
  13. 	int operator()(int month)
  14. 	{
  15. 		return _money * month;
  16. 	}
  17.  
  18. private:
  19. 	int _money;
  20. };
  21.  
  22. int main()
  23. {
  24. 	int money = 3000;
  25. 	int month = 5;
  26.  
  27. 	Salary a(money);
  28. 	cout << a(month) << endl;
  29.  
  30. 	auto func = [=] {return money * month; };
  31. 	cout << func() << endl;
  32. }

六、包装器

function 包装器也叫作适配器。C++中的function本质是一个类模板，也是一个包装器。

  1. #define _CRT_SECURE_NO_WARNINGS 1
  2.  
  3. #include <iostream>
  4. using namespace std;
  5.  
  6. template<class F, class T>
  7. T UseF(F f, T t)
  8. {
  9. 	static int count = 0;
  10. 	cout << "count: " << ++count << endl;
  11. 	cout << "count: " << &count << endl;
  12.  
  13. 	return f(t);
  14. }
  15.  
  16. double func(double x)
  17. {
  18. 	return x / 2;
  19. }
  20.  
  21. struct Func
  22. {
  23. 	double operator()(double x)
  24. 	{
  25. 		return x / 3;
  26. 	}
  27. };
  28.  
  29. int main()
  30. {
  31. 	// 函数名
  32. 	cout << UseF(func, 11.11) << endl;
  33.  
  34. 	// 函数对象
  35. 	cout << UseF(Func(), 11.11) << endl;
  36.  
  37. 	// lambda表达式
  38. 	cout << UseF([](double x) {return x / 4; }, 11.11) << endl;
  39.  
  40. 	return 0;
  41. }
  42.  
  43. // 由运行结果可见，UseF函数模板实例化了三份。
  44. // 每出现一种新的函数定义，通过UseF调用就会使UseF实例化一个新的对象，这会导致效率低下。
  45. // 包装器的出现就是为了解决这个问题。
  1. #define _CRT_SECURE_NO_WARNINGS 1
  2.  
  3. #include <iostream>
  4. #include <functional>
  5. using namespace std;
  6.  
  7. // 通过包装器提高模板函数的效率
  8. template<class F, class T>
  9. T UseF(F f, T x)
  10. {
  11. 	static int count = 0;
  12. 	cout << "count:" << ++count << endl;
  13. 	cout << "count:" << &count << endl;
  14.  
  15. 	return f(x);
  16. }
  17.  
  18. double func(double x)
  19. {
  20. 	return x / 2;
  21. }
  22.  
  23. struct Func
  24. {
  25. 	double operator()(double x)
  26. 	{
  27. 		return x / 3;
  28. 	}
  29. };
  30.  
  31. class Plus
  32. {
  33. public:
  34. 	static int plusi(int a)
  35. 	{
  36. 		return a + 1;
  37. 	}
  38.  
  39. 	double plusd(double a)
  40. 	{
  41. 		return a + 1;
  42. 	}
  43. };
  44.  
  45. int main()
  46. {
  47. 	// 函数名
  48. 	std::function<double(double)> f1 = func;
  49. 	cout << UseF(f1, 11.11) << endl;
  50.  
  51. 	// 函数对象
  52. 	std::function<double(double)> f2 = Func();
  53. 	cout << UseF(f2, 11.11) << endl;
  54.  
  55. 	// lambda表达式
  56. 	std::function<double(double)> f3 = [](double x) {return x / 4; };
  57. 	cout << UseF(f3, 11.11) << endl;
  58.  
  59. 	// 类的成员函数
  60. 	std::function<double(Plus, double)> f4 = &Plus::plusd;
  61. 	cout << f4(Plus(), 11.11) << endl;
  62.  
  63. 	return 0;
  64. }

std::bind 是一个函数模板，它就像一个函数包装器(适配器)，接受一个可调用对象（callable object），生成一个新的可调用对象来“适应”原对象的参数列表。

可以将bind函数看作是一个通用的函数适配器，它接受一个可调用对象，生成一个新的可调用对象来“适应”原对象的参数列表。

调用bind的一般形式：auto newCallable = bind(callable,arg_list);

其中，newCallable本身是一个可调用对象，arg_list是一个逗号分隔的参数列表，对应给定的callable的参数。当我们调用newCallable时，newCallable会调用callable,并传给它arg_list中的参数。

arg_list中的参数可能包含形如_n的名字，其中n是一个整数，这些参数是“占位符”，表示newCallable的参数，它们占据了传递给newCallable的参数的“位置”。数值n表示生成的可调用对象中参数的位置：_1为newCallable的第一个参数，_2为第二个参数，以此类推。

  1. #define _CRT_SECURE_NO_WARNINGS 1
  2.  
  3. // 使用举例
  4. #include <iostream>
  5. #include <functional>
  6.  
  7. int Plus(int a, int b)
  8. {
  9. 	return a + b;
  10. }
  11.  
  12. class Sub
  13. {
  14. public:
  15. 	int sub(int a, int b)
  16. 	{
  17. 		return a - b;
  18. 	}
  19. };
  20.  
  21. int main()
  22. {
  23. 	//表示绑定函数plus 参数分别由调用 func1 的第一，二个参数指定
  24. 	std::function<int(int, int)> func1 = std::bind(Plus, std::placeholders::_1,
  25. 		std::placeholders::_2);
  26.  
  27. 	//auto func1 = std::bind(Plus, placeholders::_1, placeholders::_2);
  28. 	//func2的类型为 function<void(int, int, int)> 与func1类型一样
  29. 	//表示绑定函数 plus 的第一，二为： 1， 2
  30. 	auto func2 = std::bind(Plus, 1, 2);
  31. 	std::cout << func1(1, 2) << std::endl;
  32. 	std::cout << func2() << std::endl;
  33.  
  34. 	Sub s;
  35. 	// 绑定成员函数
  36. 	std::function<int(int, int)> func3 = std::bind(&Sub::sub, s,
  37. 		std::placeholders::_1, std::placeholders::_2);
  38.  
  39. 	// 参数调换顺序
  40. 	std::function<int(int, int)> func4 = std::bind(&Sub::sub, s,
  41. 		std::placeholders::_2, std::placeholders::_1);
  42. 	std::cout << func3(1, 2) << std::endl;
  43. 	std::cout << func4(1, 2) << std::endl;
  44.  
  45. 	return 0;
  46. }

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/tf789/article/detail/62861
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号