c++11&14-常用属性专题

1. 常用属性

1.1 auto关键字及其用法

auto关键字可以用于定义变量和函数的返回值（包括声明和定义都可以），但不能用于函数形参和模板类型。示例如下：

1. #include "stdio.h"
2. auto add(int a, int b)
3. {
4. return a+b;
5. }
6. int main()
7. {
8. int a = 2, b = 3;
9. auto c = add(a, b);
10. fprintf(stderr, "c= %d\n", c);
11. return 0;
12. }

有人就会说了，上面代码中auto并没有带来优势呀，但如果是在stl中，我们经常要用到形如std::vector::iterator i;这样的来定义迭代变量，而有了auto以后，我们直接使用auto i;来定义即可，极大的简化了代码的编写。

1.2 nullptr关键字及其用法

这个关键字是用来替代NULL的，NULL在c++中表示空指针，例如有如下两个重载函数：

1. void test1(int ptr);
2. void test1(int* ptr);
3. test1(NULL);

很多人以为test1(NULL)是调用test1(int* ptr)这个，但并不是，它把NULL转换为0，调用了test1(int ptr)，所以需要使用nullptr，就不会有这种情况了。

1.3 for循环的新用法

示例如下：

1. int main()
2. {
3. int numbers[] = { 1,2,3,4,5 };
4. std::cout << "numbers:" << std::endl;
5. //类似于foreach的用法
6. for (auto number : numbers)
7. {
8. std::cout << number << std::endl;
9. }
10. }

看起来是不是比较爽，但是另外一点，写惯了老语法的人，要转变为新语法，偶尔会有点别扭，哈哈。

1.4 static_assert关键字

• static_assert关键字是c++11里面的静态断言，是在编译期断言，如果编译期不满足条件即报错；
• 因为是在编译期，所以要断言的必须是编译期能确定的值，不能是运行时才确定的值；

例如：

1. static_assert(sizeof(int) == 4);

1.6 std::function、std::bind封装可执行对象

std::bind和std::function是从boost中移植进来的C++新标准，这两个语法使得封装可执行对象变得简单而易用。

这里有一个场景：假设我们想在Test类中使用TestAdd类的成员函数Add(),那么除非我们在Test中使用TestAdd的对象，就可以做到，但如果我们现在不想这样做，怎么办呢？

这个时候就可以使用std::function和std::bind。头文件如下：

1. //test.h
2. #include <iostream>
3. #include <functional>
4. class Test
5. {
6. public:
7. //std::function<int(int,int)>
8. //表示std::function封装的可执行对象返回值和两个参数均为int类型
9. void Add(std::function<int(int, int)> fun,
   1. int a, int b)
10. {
11. int sum = fun(a, b);
12. std::cout << "sum:" << sum << std::endl;
13. }
14. };

cpp文件如下：

1. //main.cpp
2. #include <iostream>
3. #include "test.h"
5. int add(int a,int b)
6. {
7. std::cout << "add" << std::endl;
8. return a + b;
9. }
11. class TestAdd
12. {
13. public:
14. int Add(int a,int b)
15. {
16. std::cout << "TestAdd::Add" << std::endl;
17. return a + b;
18. }
19. };
21. int main()
22. {
23. Test test;
24. test.Add(add, 1, 2);
26. TestAdd testAdd;
27. test.Add(std::bind(&TestAdd::Add, testAdd,
    1. std::placeholders::_1,
    2. std::placeholders::_2), 1, 2);
28. return 0;
29. }

解释：

• std::bind第一个参数为对象函数指针，表示函数相对于类的首地址的偏移量；
• testAdd为对象指针；
• std::placeholders::1和std::placeholders::2为参数占位符，表示std::bind封装的可执行对象可以接受两个参数；

运行结果：

1. add
2. sum:3
3. TestAdd::Add
4. sum:3

也就是说std::function既支持函数指针，也支持类函数对象。