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

时间：2023-03-09 14:53:37
C++11/14的新特性——更简洁

 

新的字符串表示方式——原生字符串（Raw String Literals）

　　C/C++中提供了字符串，字符串的转义序列，给输出带来了很多不变，如果需要原生义的时候，需要反转义，比较麻烦。
　　C++提供了，原生字符串，即字符串中无转义，亦无需再反义。详细规则见带码：

#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 ;

}

新的for循环——for(x:range)

C++为 for 提供 for range 的用法。

#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

#include <iostream>

#include <vector>

#include <list>

#include <map>

using namespace std;

int main(int argc, char *argv[])

{

#if

　　vector<int> vi();

　　cout<<vi.size()<<vi.capacity()<<endl;

　　vector<int> vi2(,);

　　for(auto i: vi2){

　　　　cout<<i<<endl;

　　}

　　vector<int> vi3;

　　for(int i=; i<; i++){

　　　　vi3.push_back(i);

　　}

　　for(auto i: vi3){

　　　　cout<<i<<endl;

　　}

　　list<int> li();

　　cout<<li.size()<<endl;

　　for(auto &i:li){

　　　　cout<<i<<endl;

　　}

　　list<int> li2(,);

　　cout<<li2.size()<<endl;

　　for(auto &i:li2){

　　cout<<i<<endl;

　　}

　　list<int> li3;

　　for(int i=; i<; 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>(,"c++"));

　　mis.insert(pair<int,string>(,"java"));

　　mis.insert(pair<int,string>(,"python"));

　　mis.insert(map<int,string>::value_type(,"c"));

　　mis.insert(map<int,string>::value_type(,"php"));

　　for(auto is: mis)

　　{

　　cout<<is.first<<"\t"<<is.second<<endl;

　　}

　　mis[] = "scala";

　　mis[] = "basic";

　　mis[] = "ruby";

　　for(auto &is: mis)

　　{

　　cout<<is.first<<"\t"<<is.second<<endl;

　　}

　　return ;

}

2)初始化列表——Initializer List

#include <iostream>

#include <vector>

#include <list>

#include <map>

using namespace std;

int main(int argc, char *argv[])

{

    vector<int> iv = {,,,,};

    list<int> li = {,,,,};

    map<int,string> mis = {{,"c"},{,"c++"},

                                       {,"java"},{,"scala"},

                                       {,"python"}};

    mis.insert({,"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 ;

}

3)initializer_list<T>（作入参）

#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 = { , , ,  };

    return ;

}

统一的初始化风格(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 <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 {,};

} 

int main(int argc, char *argv[])

{

    int a = ;

    int aa[] = {,,};

    complex com(,);

//---------------------------

    int a_ = {};

    int aa_[] = {,,};

    complex com_ = {,};

    func({,});

    return ;

}

auto自动类型推导

1）引入

#include <iostream>

using namespace std;

int func()

{

    return ;

} 

int main(int argc, char *argv[])

{

    auto i = ;

    auto &ri = i;

    auto rf = func();

    const auto *p = &ri;

    static auto si = ;

    return ;

}

2）语法

auto 能够实现类型的自我推导，并不代表一个实际的类型声明。auto 只是一个类型声明的占位符。
auto 声明的变量，必须马上初始化，以让编译器推断出它的实际类型，并在编译时将 auto 占位符替换为真正的类型。

3）用法

  • 不用于函数参数
#include <iostream>

#include <vector>

using namespace std;

//void foo(auto i)

//{

// cout<<i<<endl;

//}

int main(int argc, char *argv[])

{

    int arr[] = {};

    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 ;

}
  • 常用于STL

　　如迭代器的初始化，容器拷贝等。

decltype-类型指示器

1）获取表达式类型

　　auto 类型，作为占位符的存在来修饰变量，必须初始化，编译器通过初始化来确定 auto 所代表的类型。即必须定义变量。

　　如果，我仅希望得到类型，而不是具体的变量产生关系，该如何作到呢？decltype(expr); expr 代表被推导的表达式。由decltype推导所声明难过的变量，可初始化，也可不初始化。

#include <iostream>

using namespace std;

int func()

{

    return ;

} 

int main(int argc, char *argv[])

{

    int a = ;

    cout<<sizeof(a)<<endl;

    decltype(a) b = ;　　//！decltype(a) == int

    decltype(a+b) c = ;

    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 ;

}

2）推导规则

　　decltype(expr); 所推导出来的类型，完全与 expr 类型一致。同 auto 一样，在编译期间完成，并不会真正计算表达式的值。
应用

3）decltype与typedef联合应用

#include <iostream>

#include <vector>

#include <map>

using namespace std;

int main(int argc, char *argv[])

{

    vector<int> vi = {,,,,,};

    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(,"abc"));

    mis.insert(decltype(mis)::value_type(,"java"));

    typedef decltype(map<int,string>::value_type()) Int2String;

　　 mis.insert(Int2String(,"c++"));

    for(auto& is:mis)

    {

        cout<<is.first<<is.second<<endl;

    }

    return ;

}

4）decltype +auto

　　C++11 增了返回类型后置(trailing-return-type,或跟踪返回类型)，将 decltype 和 auto结合起来完成返回类型的推导。

#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 = ;

    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 ;

}

仿函数（functor）

1）语法

　　重载了 operator()的类的对象，在使用中，语法类型于函数。故称其为仿函数。此种用法优于常见的函数回调。

class Add

{

public:

    int operator()(int x, int y)

    {

        return x+y;

    }

};

2）应用

#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 =  , b = ;

    Add add;

    cout<<add(a,b)<<endl;

    return ;

}

3）提高（带状态的functor）

　　相对于函数，仿函数，可以拥用初始状态，一般通过 class 定义私有成员，并在声明对象的时候，进行初始化。私有成员的状态，就成了仿函数的初始状态。而由于声明一个仿函数对象可以拥有多个不同初始状态的实例。

#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,);

    Tax middle(0.25,);

    Tax low(0.12,);

    cout<<"大于 3w 的税:"<<high()<<endl;

    cout<<"大于 2w 的税:"<<middle()<<endl;

    return ;

}

相关文章