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

其他 2018-07-09 20:03:33 阅读次数: 0

 

原生字符串（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 0;
}

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

#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>（作入参）

#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++中的初始化风格，大体有如下形式：

  • 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 {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;
}

自动类型推导

1）引入

#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）用法

  • 不用于函数参数
#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;
    cout<<sizeof(aa)<<sizeof(aa)<<endl;
    // auto aaa[10] = arr;
    vector<int> vi;
    auto ivcp = vi;
    // vector<auto> va = vi;
    return 0;
}
  • 常用于STL

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

decltype

1）获取表达式类型

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

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

#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联合应用

#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结合起来完成返回类型的推导。

#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()的类的对象，在使用中，语法类型于函数。故称其为仿函数。此种用法优于常见的函数回调。

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 = 1 , b = 2;
    Add add;
    cout<<add(a,b)<<endl;
    return 0;
}

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,30000);
    Tax middle(0.25,20000);
    Tax low(0.12,10000);
    cout<<"大于 3w 的税:"<<high(37500)<<endl;
    cout<<"大于 2w 的税:"<<middle(27500)<<endl;
    return 0;
}

猜你喜欢

转载自www.cnblogs.com/wangkeqin/p/9285682.html
今日推荐
TIOBE 5 月榜单：Fortran “复活”进入 Top 10
GCC 14.1 发布
面壁智能发布 Eurux-8x22B 开源大模型 —— 堪称「理科状元」
开源日报 | 谷歌扶持鸿蒙上位；开源Rabbit R1；Docker加持的安卓手机；微软的焦虑和野心；海尔电器把开放平台关了
中国码农的“35岁魔咒”
蘭雅 CorelDRAW 插件 2024.5.1 国际劳动节版，免费下载
Arc Browser for Windows 1.0 正式 GA
90后程序员开发视频搬运软件、不到一年获利超 700 万，结局很刑！
周排行
Java自定义时间格式
同步整形电路
在开发中最最最常用的字符串的属性大集合
Linux 查看端口占用并杀掉
Java基础四：ArrayList
多线程之死锁就是这么简单
mysql 基础命令集
awk 命令详解
Centos6.3编译安装nginx+php步骤
OCR （Optical Character Recognition，光学字符识别）
每日归档
更多
2024-05-08(42)
2024-05-07(14)
2024-05-06(40)
2024-05-05(0)
2024-05-04(7)
2024-05-03(19)
2024-05-02(0)
2024-05-01(4)
2024-04-30(1)
2024-04-29(40)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022