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

2023-08-31 10:50:04 78
新的字符串表示方式——原生字符串（RawStringLiterals）
C/C++中提供了字符串，字符串的转义序列，给输出带来了很多不变，如果需要原生义的时候，需要反转义，比较麻烦。
C++提供了，原生字符串，即字符串中无转义，亦无需再反义。详细规则见带码：
#include
usingnamespacestd;

stringpath="C:\ProgramFiles(x86)\alipay\aliedit\5.1.0.3754";
stringpath2="C:\\ProgramFiles(x86)\\alipay\\aliedit\\5.1.0.3754";
//更简洁的表示
stringpath3=R"(C:\ProgramFiles(x86)\alipay\aliedit\5.1.0.3754)";
stringpath4=R"(C:\Program"Files"(x86)\\alipay\aliedit\5.1.0.3754)";


intmain(intargc,char*argv[])
{
cout<
新的for循环——for(x:range)
C++为for提供forrange的用法。
#include
#include
#include
usingnamespacestd;
intmain(intargc,char*argv[])
{
stringstr="china";
//！字符数组
for(autoch:str)
{
cout<vs={"abc","xyz","mnq"};
vector::iteratoritr=vs.begin();
for(;itr!=vs.end();itr++)
{
cout<<*itr<mis={{1,"c++"},{2,"java"},{3,"python"}};
map::iteratoritr=mis.begin();
for(;itr!=mis.end();++itr)
{
cout<<(*itr).first<<"\t"<second<
新的初始化的方式——InitializerList
1）常规方法——normalinit
#include
#include

#include
#include
usingnamespacestd;
intmain(intargc,char*argv[])
{
#if0
vectorvi(5);
cout<vi2(5,10);
for(autoi:vi2){
cout<vi3;
for(inti=0;i<10;i++){
vi3.push_back(i);
}
for(autoi:vi3){
cout<li(5);
cout<li2(5,10);
cout<li3;
for(inti=0;i<10;i++)
{
li3.push_back(i);
}
cout<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(autois:mis)
{
cout<
2)初始化列表——InitializerList
#include
#include
#include
#include

usingnamespacestd;

intmain(intargc,char*argv[])
{
vectoriv={1,2,3,4,5};
listli={1,2,3,4,5};
mapmis={{1,"c"},{2,"c++"},
{3,"java"},{4,"scala"},
{5,"python"}};
mis.insert({6,"ruby"});
//map::iteratoritr=mis.begin();
//for(;itr!=mis.end();++itr)
//{
//cout<first<second<
3)initializer_list（作入参）
#include
#include
usingnamespacestd;
template
classMyArray
{
private:
vectorm_Array;
public:
MyArray(){}
MyArray(constinitializer_list&il)
{
for(autox:il)
m_Array.push_back(x);
}
};

intmain()
{
MyArrayfoo={3,4,6,9};
return0;
}
统一的初始化风格(Uniforminitialization)
C++中的初始化风格，大体有如下形式：


inta=2;//"赋值风格"的初始化
intaa[]={2,3};//用初始化列表进行的赋值风格的初始化
complexz(1,2);//"函数风格"的初始化
C++11中，允许通过以花括号的形式来调用构造函数。这样多种对象构造方式便可以统一起来了：


inta={2};
intaa[]={2,3};
complexz={1,2};
#include
usingnamespacestd;

classcomplex
{
public:
complex(intx,inty)
:_x(x),_y(y){}
private:
int_x;
int_y;
};

complexfunc(constcomplex&com)
{
return{1,2};
}

intmain(intargc,char*argv[])
{
inta=10;
intaa[]={1,2,3};
complexcom(1,2);

//---------------------------
inta_={1};
intaa_[]={1,2,3};
complexcom_={1,2};
func({1,2});
return0;
}


auto自动类型推导
1）引入
#include
usingnamespacestd;

intfunc()
{
return8;
}

intmain(intargc,char*argv[])
{
autoi=5;
auto&ri=i;
autorf=func();
constauto*p=&ri;
staticautosi=100;
return0;
}
2）语法
auto能够实现类型的自我推导，并不代表一个实际的类型声明。auto只是一个类型声明的占位符。

auto声明的变量，必须马上初始化，以让编译器推断出它的实际类型，并在编译时将auto占位符替换为真正的类型。
3）用法

不用于函数参数

#include
#include

usingnamespacestd;

//voidfoo(autoi)
//{
//cout<vi;
autoivcp=vi;
//vectorva=vi;
return0;
}

常用于STL

如迭代器的初始化，容器拷贝等。
decltype-类型指示器
1）获取表达式类型
auto类型，作为占位符的存在来修饰变量，必须初始化，编译器通过初始化来确定auto所代表的类型。即必须定义变量。
如果，我仅希望得到类型，而不是具体的变量产生关系，该如何作到呢？decltype(expr);expr代表被推导的表达式。由decltype推导所声明难过的变量，可初始化，也可不初始化。 
#include
usingnamespacestd;

intfunc()
{
return1;
}

intmain(intargc,char*argv[])
{
inta=10;
cout<
2）推导规则
decltype(expr);所推导出来的类型，完全与expr类型一致。同auto一样，在编译期间完成，并不会真正计算表达式的值。

应用
3）decltype与typedef联合应用
#include
#include
#include

usingnamespacestd;

intmain(intargc,char*argv[])
{
vectorvi={1,2,3,4,5,0};

typedefdecltype(vi.begin())Itr;

for(Itritr=vi.begin();itr!=vi.end();++itr)
{
cout<<*itr<mis;
mis.insert(map::value_type(1,"abc"));
mis.insert(decltype(mis)::value_type(2,"java"));

typedefdecltype(map::value_type())Int2String;

mis.insert(Int2String(3,"c++"));
for(auto&is:mis)
{
cout<
4）decltype+auto
C++11增了返回类型后置(trailing-return-type,或跟踪返回类型)，将decltype和auto结合起来完成返回类型的推导。 
#include

usingnamespacestd;

template
Radd(Ta,Ub)
{
returna+b;
}

template
autoadd2(Ta,Ub)->decltype(a+b)
{
returna+b;
}

intmain(intargc,char*argv[])
{
inta=1;
floatb=1.1;
autoret=add(a,b);
cout<(a,b);
cout<
仿函数（functor）
1）语法
重载了operator()的类的对象，在使用中，语法类型于函数。故称其为仿函数。此种用法优于常见的函数回调。 
classAdd
{
public:
intoperator()(intx,inty)
{
returnx+y;
}
};


2）应用
#include
usingnamespacestd;
classAdd
{
public:
intoperator()(intx,inty)
{
returnx+y;
}
};

intmain(intargc,char*argv[])
{
inta=1,b=2;
Addadd;
cout<
3）提高（带状态的functor）
相对于函数，仿函数，可以拥用初始状态，一般通过class定义私有成员，并在声明对象的时候，进行初始化。私有成员的状态，就成了仿函数的初始状态。而由于声明一个仿函数对象可以拥有多个不同初始状态的实例。 
#include

usingnamespacestd;

classTax
{
public:
Tax(floatr,floatb):_rate(r),_base(b){}

floatoperator()(floatmoney)
{
return(money-_base)*_rate;
}
private:
float_rate;
float_base;
};

intmain(intargc,char*argv[])
{
Taxhigh(0.40,30000);
Taxmiddle(0.25,20000);
Taxlow(0.12,10000);
cout<<"大于3w的税:"<
以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持毛票票。
C++11/14的新特性(更简洁)

热门推荐

随机推荐
