个人中心
gpt4 book ai didi

C++11/14的新特性(更简洁)

转载 作者：qq735679552 更新时间：2022-09-28 22:32:09 40 4
gpt4 key购买 nike

CFSDN坚持开源创造价值，我们致力于搭建一个资源共享平台，让每一个IT人在这里找到属于你的精彩世界.

这篇CFSDN的博客文章C++11/14的新特性(更简洁)由作者收集整理，如果你对这篇文章有兴趣，记得点赞哟.

新的字符串表示方式——原生字符串（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 。

最后此篇关于C++11/14的新特性(更简洁)的文章就讲到这里了,如果你想了解更多关于C++11/14的新特性(更简洁)的内容请搜索CFSDN的文章或继续浏览相关文章，希望大家以后支持我的博客！ 。

40 4 0
文章推荐： C++11/14 线程中使用Lambda函数的方法
文章推荐： Python爬虫数据的分类及json数据使用小结
文章推荐： Python爬虫爬取全球疫情数据并存储到mysql数据库的步骤
文章推荐： python 利用百度API进行淘宝评论关键词提取
qq735679552
个人简介

我是一名优秀的程序员,十分优秀！

滴滴打车优惠券免费领取
滴滴打车优惠券
全站热门文章
Copyright 2021 - 2024 cfsdn All Rights Reserved 蜀ICP备2022000587号
广告合作:1813099741@qq.com 6ren.com