新的字符串表示方式——原生字符串（Raw String Literals）
C/C++中提供了字符串，字符串的转义序列，给输出带来了很多不变，如果需要原生义的时候，需要反转义，比较麻烦。
C++提供了，原生字符串，即字符串中无转义，亦无需再反义。详细规则见带码：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
#include <iostream>using namespace std;string path = "C:\Program Files (x86)\alipay\aliedit\5.1.0.3754";string path2 = "C:\\Program Files (x86)\\alipay\\aliedit\\5.1.0.3754";//更简洁的表示string path3 = R"(C:\Program Files (x86)\alipay\aliedit\5.1.0.3754)";string path4 = R"(C:\Program "Files" (x86)\\alipay\aliedit\5.1.0.3754)";int main(int argc, char *argv[]){ cout<<path<<endl; cout<<path2<<endl; cout<<path3<<endl; cout<<path4<<endl; return 0;} |
新的for循环——for(x:range)
C++为 for 提供 for range 的用法。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
|
#include <iostream>#include <vector>#include <map>using namespace std;int main(int argc, char *argv[]){ string str = "china"; //！字符数组 for(auto ch: str) { cout<<ch<<endl; } int arr[] = {1,2,3,4}; //！普通数组 for(auto i: arr) { cout<<i<<endl; } vector<string> vs = {"abc","xyz","mnq"}; vector<string>::iterator itr = vs.begin(); for(; itr != vs.end(); itr++) { cout<<*itr<<endl; } //！vector for(auto &s : vs) { cout<<s<<endl; } map<int,string> mis={{1,"c++"},{2,"java"},{3,"python"}}; map<int,string>::iterator itr = mis.begin(); for(; itr != mis.end(); ++itr) { cout<<(*itr).first<<"\t"<<itr->second<<endl; } //！map for(auto &pair: mis) { cout<<pair.first<<"\t"<<pair.second<<endl; } return 0;} |
新的初始化的方式——Initializer List
1）常规方法——normal init
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
|
#include <iostream>#include <vector>#include <list>#include <map>using namespace std;int main(int argc, char *argv[]){ #if 0 vector<int> vi(5); cout<<vi.size()<<vi.capacity()<<endl; vector<int> vi2(5,10); for(auto i: vi2){ cout<<i<<endl; } vector<int> vi3; for(int i=0; i<10; i++){ vi3.push_back(i); } for(auto i: vi3){ cout<<i<<endl; } list<int> li(5); cout<<li.size()<<endl; for(auto &i:li){ cout<<i<<endl; } list<int> li2(5,10); cout<<li2.size()<<endl; for(auto &i:li2){ cout<<i<<endl; } list<int> li3; for(int i=0; i<10; i++) { li3.push_back(i); } cout<<li3.size()<<endl; for(auto &i:li3){ cout<<i<<endl; }#endif map<int,string> mis; mis.insert(pair<int,string>(1,"c++")); mis.insert(pair<int,string>(2,"java")); mis.insert(pair<int,string>(3,"python")); mis.insert(map<int,string>::value_type(4,"c")); mis.insert(map<int,string>::value_type(5,"php")); for(auto is: mis) { cout<<is.first<<"\t"<<is.second<<endl; } mis[6] = "scala"; mis[7] = "basic"; mis[8] = "ruby"; for(auto &is: mis) { cout<<is.first<<"\t"<<is.second<<endl; } return 0;} |
2)初始化列表——Initializer List
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
|
#include <iostream>#include <vector>#include <list>#include <map>using namespace std;int main(int argc, char *argv[]){ vector<int> iv = {1,2,3,4,5}; list<int> li = {1,2,3,4,5}; map<int,string> mis = {{1,"c"},{2,"c++"}, {3,"java"},{4,"scala"}, {5,"python"}}; mis.insert({6,"ruby"}); // map<int,string>::iterator itr = mis.begin(); // for(; itr != mis.end(); ++itr) // { // cout<<itr->first<< itr->second<<endl; // } for(auto &is: mis) { cout<<is.first<<is.second<<endl; } return 0;} |
3)initializer_list<T>（作入参）
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
|
#include <iostream>#include <vector>using namespace std;template <typename T>class MyArray{ private: vector<T> m_Array;public: MyArray() { } MyArray(const initializer_list<T>& il) { for (auto x : il) m_Array.push_back(x); }};int main(){ MyArray<int> foo = { 3, 4, 6, 9 }; return 0;} |
统一的初始化风格(Uniform initialization)
C++中的初始化风格，大体有如下形式：
|
1
2
3
|
int a = 2; //"赋值风格"的初始化int aa [] = { 2, 3 }; //用初始化列表进行的赋值风格的初始化complex z(1, 2); //"函数风格"的初始化 |
C++ 11 中，允许通过以花括号的形式来调用构造函数。这样多种对象构造方式便可以统一起来了：
|
1
2
3
|
int a = { 2 };int aa [] = { 2, 3 };complex z = { 1, 2 }; |
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
|
#include <iostream>using namespace std;class complex{ public: complex(int x, int y) :_x(x),_y(y){} private: int _x; int _y;};complex func(const complex & com){ return {1,2};} int main(int argc, char *argv[]){ int a = 10; int aa[] = {1,2,3}; complex com(1,2);//--------------------------- int a_ = {1}; int aa_[] = {1,2,3}; complex com_ = {1,2}; func({1,2}); return 0;} |
auto自动类型推导
1）引入
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
#include <iostream>using namespace std;int func(){ return 8;} int main(int argc, char *argv[]){ auto i = 5; auto &ri = i; auto rf = func(); const auto *p = &ri; static auto si = 100; return 0;} |
2）语法
auto 能够实现类型的自我推导，并不代表一个实际的类型声明。auto 只是一个类型声明的占位符。
auto 声明的变量，必须马上初始化，以让编译器推断出它的实际类型，并在编译时将 auto 占位符替换为真正的类型。
3）用法
- 不用于函数参数
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
#include <iostream>#include <vector>using namespace std;//void foo(auto i)//{// cout<<i<<endl;//}int main(int argc, char *argv[]){ int arr[10] = {0}; auto aa = arr; //！auto == const int * cout<<sizeof(aa)<<sizeof(aa)<<endl; // auto aaa[10] = arr; //！错误的用法：C/C++中数组不可以直接赋值的属性是不可违背的。 vector<int> vi; auto ivcp = vi; // vector<auto> va = vi; return 0;} |
- 常用于STL
如迭代器的初始化，容器拷贝等。
decltype-类型指示器
1）获取表达式类型
auto 类型，作为占位符的存在来修饰变量，必须初始化，编译器通过初始化来确定 auto 所代表的类型。即必须定义变量。
如果，我仅希望得到类型，而不是具体的变量产生关系，该如何作到呢？decltype(expr); expr 代表被推导的表达式。由decltype推导所声明难过的变量，可初始化，也可不初始化。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
|
#include <iostream>using namespace std;int func(){ return 1;} int main(int argc, char *argv[]){ int a = 10; cout<<sizeof(a)<<endl; decltype(a) b = 20; //！decltype(a) == int decltype(a+b) c = 30; cout<<a<<b<<c<<endl; const int & cira = a; decltype(cira) cirb = b; cout<<cira<<cirb<<endl; int *pa = &a; decltype(pa) pb = &b; cout<<&a<<"\t"<<pa<<endl; cout<<&b<<"\t"<<pb<<endl; decltype(func()) df; cout<<sizeof(df)<<endl; return 0;} |
2）推导规则
decltype(expr); 所推导出来的类型，完全与 expr 类型一致。同 auto 一样，在编译期间完成，并不会真正计算表达式的值。
应用
3）decltype与typedef联合应用
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
|
#include <iostream>#include <vector>#include <map>using namespace std;int main(int argc, char *argv[]){ vector<int> vi = {1,2,3,4,5,0}; typedef decltype(vi.begin()) Itr; for(Itr itr = vi.begin(); itr != vi.end(); ++itr) { cout<<*itr<<endl; } map<int,string> mis; mis.insert(map<int,string>::value_type(1,"abc")); mis.insert(decltype(mis)::value_type(2,"java")); typedef decltype(map<int,string>::value_type()) Int2String; mis.insert(Int2String(3,"c++")); for(auto& is:mis) { cout<<is.first<<is.second<<endl; } return 0;} |
4）decltype +auto
C++11 增了返回类型后置(trailing-return-type,或跟踪返回类型)，将 decltype 和 auto结合起来完成返回类型的推导。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
|
#include <iostream>using namespace std;template<typename R, typename T,typename U>R add(T a, U b){ return a+b;} template<typename R, typename T,typename U>auto add2(T a, U b)->decltype(a+b){ return a+b;} int main(int argc, char *argv[]){ int a = 1; float b = 1.1; auto ret = add<decltype(a+b),int,float>(a,b); cout<<ret<<endl; auto ret2 = add2<decltype(a+b)>(a,b); cout<<ret2<<endl; return 0;} |
仿函数（functor）
1）语法
重载了 operator()的类的对象，在使用中，语法类型于函数。故称其为仿函数。此种用法优于常见的函数回调。
|
1
2
3
4
5
6
7
8
|
class Add{ public: int operator()(int x, int y) { return x+y; }}; |
2）应用
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
#include <iostream>using namespace std;class Add{ public: int operator()(int x, int y) { return x+y; }};int main(int argc, char *argv[]){ int a = 1 , b = 2; Add add; cout<<add(a,b)<<endl; return 0;} |
3）提高（带状态的functor）
相对于函数，仿函数，可以拥用初始状态，一般通过 class 定义私有成员，并在声明对象的时候，进行初始化。私有成员的状态，就成了仿函数的初始状态。而由于声明一个仿函数对象可以拥有多个不同初始状态的实例。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
|
#include <iostream>using namespace std;class Tax{ public: Tax(float r, float b):_rate(r),_base(b){} float operator()(float money) { return (money-_base)*_rate; } private: float _rate; float _base;};int main(int argc, char *argv[]){ Tax high(0.40,30000); Tax middle(0.25,20000); Tax low(0.12,10000); cout<<"大于 3w 的税:"<<high(37500)<<endl; cout<<"大于 2w 的税:"<<middle(27500)<<endl; return 0;} |
以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持服务器之家。
原文链接：https://www.cnblogs.com/wangkeqin/p/9285682.html
