您的位置：首页 > 教程文章 > 编程开发

同类最新

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

： ：0 ：2021-04-27 18:47:15

新的字符串表示方式——原生字符串（Raw String Literals）
C/C++中提供了字符串，字符串的转义序列，给输出带来了很多不变，如果需要原生义的时候，需要反转义，比较麻烦。
C++提供了，原生字符串，即字符串中无转义，亦无需再反义。详细规则见带码：
#include
using namespace std;
string path = "C:Program Files (x86)alipayaliedit5.1.0.3754";
string path2 = "C:\Program Files (x86)\alipay\aliedit\5.1.0.3754";
//更简洁的表示
string path3 = R"(C:Program Files (x86)alipayaliedit5.1.0.3754)";
string path4 = R"(C:Program "Files" (x86)\alipayaliedit5.1.0.3754)";

int main(int argc, char *argv[])
{
　　cout<　　cout<　　cout<　　cout<　　return 0;
}
新的for循环——for(x:range)
C++为 for 提供 for range 的用法。
#include
#include
#include
using namespace std;
int main(int argc, char *argv[])
{
string str = "china";
　　 //！字符数组
for(auto ch: str)
{
cout< }
　　int arr[] = {1,2,3,4};
　　//！普通数组
　　for(auto i: arr)
　　{
　　　　cout<　　}
　　
　　vector vs = {"abc","xyz","mnq"};
　　vector::iterator itr = vs.begin();
　　for(; itr != vs.end(); itr++)
　　{
　　　　cout<<*itr<　　}
　　//！vector
　　for(auto &s : vs)
　　{
　　　　cout<　　}
　　map mis={{1,"c++"},{2,"java"},{3,"python"}};
　　map::iterator itr = mis.begin();
　　for(; itr != mis.end(); ++itr)
　　{
　　　　cout<<(*itr).first<<"t"<second<　　}
　　//！map
　　for(auto &pair: mis)
　　{
　　　　cout<　　}
　　return 0;
}
新的初始化的方式——Initializer List
1）常规方法——normal init
#include
#include
#include
#include
using namespace std;
int main(int argc, char *argv[])
{
#if 0
　　vector vi(5);
　　cout<　　vector vi2(5,10);
　　for(auto i: vi2){
　　　　cout<　　}
　　vector vi3;
　　for(int i=0; i<10; i++){
　　　　vi3.push_back(i);
　　}
　　for(auto i: vi3){
　　　　cout<　　}
　　list li(5);
　　cout<　　for(auto &i:li){
　　　　cout<　　}
　　list li2(5,10);
　　cout<　　for(auto &i:li2){
　　cout<　　}
　　list li3;
　　for(int i=0; i<10; i++)
　　{
　　　　li3.push_back(i);
　　}
　　cout<　　for(auto &i:li3){
　　　　cout<　　}
#endif
　　map mis;
　　mis.insert(pair(1,"c++"));
　　mis.insert(pair(2,"java"));
　　mis.insert(pair(3,"python"));
　　mis.insert(map::value_type(4,"c"));
　　mis.insert(map::value_type(5,"php"));
　　for(auto is: mis)
　　{
　　cout<　　}
　　mis[6] = "scala";
　　mis[7] = "basic";
　　mis[8] = "ruby";
　　for(auto &is: mis)
　　{
　　cout<　　}
　　return 0;
}
2)初始化列表——Initializer List
#include
#include
#include
#include
using namespace std;
int main(int argc, char *argv[])
{
vector iv = {1,2,3,4,5};
list li = {1,2,3,4,5};
map mis = {{1,"c"},{2,"c++"},
{3,"java"},{4,"scala"},
{5,"python"}};
mis.insert({6,"ruby"});
// map::iterator itr = mis.begin();
// for(; itr != mis.end(); ++itr)
// {
// cout<first<< itr->second< // }
for(auto &is: mis)
{
cout< }
return 0;
}
3)initializer_list（作入参）
#include
#include
using namespace std;
template
class MyArray
{
private:
vector m_Array;
public:
MyArray() { }
MyArray(const initializer_list& il)
{
for (auto x : il)
m_Array.push_back(x);
}
};
int main()
{
MyArray foo = { 3, 4, 6, 9 };
return 0;
}
统一的初始化风格(Uniform initialization)
C++中的初始化风格，大体有如下形式：
int a = 2; //"赋值风格"的初始化
int aa [] = { 2, 3 }; //用初始化列表进行的赋值风格的初始化
complex z(1, 2); //"函数风格"的初始化
C++ 11 中，允许通过以花括号的形式来调用构造函数。这样多种对象构造方式便可以统一起来了：
int a = { 2 };
int aa [] = { 2, 3 };
complex z = { 1, 2 };
#include
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）引入
#include
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）用法
不用于函数参数
#include
#include
using namespace std;
//void foo(auto i)
//{
// cout<//}
int main(int argc, char *argv[])
{
int arr[10] = {0};
auto aa = arr; //！auto == const int *
cout< // auto aaa[10] = arr; //！错误的用法：C/C++中数组不可以直接赋值的属性是不可违背的。
vector vi;
auto ivcp = vi;
// vector va = vi;
return 0;
}
常用于STL
如迭代器的初始化，容器拷贝等。
decltype-类型指示器
1）获取表达式类型
auto 类型，作为占位符的存在来修饰变量，必须初始化，编译器通过初始化来确定 auto 所代表的类型。即必须定义变量。
如果，我仅希望得到类型，而不是具体的变量产生关系，该如何作到呢？decltype(expr); expr 代表被推导的表达式。由decltype推导所声明难过的变量，可初始化，也可不初始化。
#include
using namespace std;
int func()
{
return 1;
}
int main(int argc, char *argv[])
{
int a = 10;
cout< decltype(a) b = 20;　　//！decltype(a) == int
decltype(a+b) c = 30;
cout< const int & cira = a;
decltype(cira) cirb = b;
cout< int *pa = &a;
decltype(pa) pb = &b;
cout<<&a<<"t"< cout<<&b<<"t"< decltype(func()) df;
cout< return 0;
}
2）推导规则
decltype(expr); 所推导出来的类型，完全与 expr 类型一致。同 auto 一样，在编译期间完成，并不会真正计算表达式的值。
应用
3）decltype与typedef联合应用
#include
#include
#include
using namespace std;
int main(int argc, char *argv[])
{
vector vi = {1,2,3,4,5,0};
typedef decltype(vi.begin()) Itr;
for(Itr itr = vi.begin(); itr != vi.end(); ++itr)
{
cout<<*itr< }
map mis;
mis.insert(map::value_type(1,"abc"));
mis.insert(decltype(mis)::value_type(2,"java"));
typedef decltype(map::value_type()) Int2String;

　　 mis.insert(Int2String(3,"c++"));
for(auto& is:mis)
{
cout< }
return 0;
}
4）decltype +auto
C++11 增了返回类型后置(trailing-return-type,或跟踪返回类型)，将 decltype 和 auto结合起来完成返回类型的推导。
#include
using namespace std;
template
R add(T a, U b)
{
return a+b;
}
template
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(a,b);
cout< auto ret2 = add2(a,b);
cout< return 0;
}
仿函数（functor）
1）语法
重载了 operator()的类的对象，在使用中，语法类型于函数。故称其为仿函数。此种用法优于常见的函数回调。
class Add
{
public:
int operator()(int x, int y)
{
return x+y;
}
};

2）应用
#include
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< return 0;
}
3）提高（带状态的functor）
相对于函数，仿函数，可以拥用初始状态，一般通过 class 定义私有成员，并在声明对象的时候，进行初始化。私有成员的状态，就成了仿函数的初始状态。而由于声明一个仿函数对象可以拥有多个不同初始状态的实例。
#include
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 的税:"< cout<<"大于 2w 的税:"< return 0;
}
以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持无名。

C++11/14 线程中使用Lambda函数的方法
C++实现幸运大抽奖（QT版）

同类资源