c++ 11/14新特性

最新推荐文章于 2021-12-18 15:00:09 发布
最新推荐文章于 2021-12-18 15:00:09 发布
阅读量137 收藏
点赞数
分类专栏： 面试题 c++精华学习笔记
原文链接：https://www.cnblogs.com/wangkeqin/p/9285682.html
版权

// C++11 新增特性

// 1、自动类型推导  ====> auto
int main1()
{
    auto a = 10;   // a 是 int 类型
    auto d = 1.2;  // d 是 double 类型
    auto f = 2.3;  // f 是 float 类型

    cout << a << d << f << endl;
    return 0;
}

// 2、空指针类型 nullptr  为了和 NULL 进行区分
int main2()
{
    int *p = nullptr;

    return 0;
}

// 3、统一初始化: 所有变量都可以用 {} 进行初始化
int main3()
{
    int a{10};
    cout << a << endl;

    char c{'A'};

    int arr[20]{1,2,3,4,5,6,7,8};

    int *p1 = new int{10};
    cout <<*p1 << endl;

    int *p2 = new int[10]{1,2,3,4,5,6,7};
    for (int i = 0; i < 10; i++)
    {
        cout << p2[i] << endl;
    }
    delete p1;
    delete[] p2;


    return 0;
}

// 4、初始化列表 initializer_list<元素类型>
// 列表中提供两个函数  begin  一个 end 分别指向列表第一个元素和最后一个元素的下一个元素
// 可以认为他们是个指针

void func(initializer_list<int> nums, int aa)
{
    auto pa = nums.begin();  // pa 是第一个元素的 “指针”
    auto pb = nums.end();    // pb 是指向最后一个元素的下一个元素的 “指针”

    while (pa != pb)
    {
        cout << *pa << endl;

        pa++;
    }

    for (auto pa = nums.begin(); pa != nums.end(); pa++)
    {
        cout << *pa << endl;
    }

    for (auto num : nums)
    {
        cout << num << " ";
    }
    cout << endl;
}
int main4()
{

    func({1,2,3,4,5,6,7,8}, 10);

    return 0;
}


//  for 新的遍历形式
int main()
{
    int arr[10] {1,2,3,4,5,6,7,8,9,10};

    for (int i = 0; i < 10; i++)
    {
        cout << arr[i] << endl;
    }

    for (int a : arr)
    {
        cout << a << " ";
    }
    cout << endl;


    return 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循环——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;
}

auto自动类型推导

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; //！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推导所声明难过的变量，可初始化，也可不初始化。
#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;
}
复制代码
 

aFakeProgramer
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++11/14新特性
04-14
C++11/14新特性
C++11/14的新特性——更简洁
weixin_30345055的博客
07-09 114
新的字符串表示方式——原生字符串（Raw String Literals） 　　C/C++中提供了字符串，字符串的转义序列，给输出带来了很多不变，如果需要原生义的时候，需要反转义，比较麻烦。　　C++提供了，原生字符串，即字符串中无转义，亦无需再反义。详细规则见带码： #include <iostream> using namespace std; string pa...
现代C++语言（C++11/14/17）特性总结和使用建议（一）
勤学如春起之苗，不见其增，日有所长！ 辍学如磨刀之石，不见其损，日有所亏！
01-09 2016
C++语言在历史上经过了很多次的演进。最早的时候，C++语言没有模板、STL、异常等特性，之后加入这些特性形成大多数人所熟悉的C++98/03标准。在此之后，C++经过10多年又孕育出了拥有众多革命性变化的C++11标准（在标准正式发布前，被称为C++0x）。C++11包括了约140个新特性和约600个缺陷的修正。由于其变化实在太大，被很多人称为“现代C++语言”（Modern C++ La...
C++ 11 和 C++ 14的新特性
大西瓜不甜的博客
03-30 3533
C++11：C++11包括大量的新特性：包括lambda表达式，类型推导关键字auto、decltype，和模板的大量改进。 新的关键字 auto C++11中引入auto第一种作用是为了自动类型推导 auto的自动类型推导，用于从初始化表达式中推断出变量的数据类型。通过auto的自动类型推导，可以大大简化我们的编程工作 auto实际上实在编译时对变量进行了类型推导，所以不会对程序...
c++11、14新特性
chixuzhendang的博客
12-18 1296
参考自：c++ primer plus、c++标准库 小功能 std::initializer_list 这是一个模板类，可用于容器构造时的初始化，初始列中的元素必须为同一类型（或者可以转换成同一类型）。 vector<int> vecTest {10, 6, 7}; string str {"abc"}; // 也可以声明该模板类的对象，以便进行函数调用 void print(std::initializer_list<int> initList) { for(auto beg
C++11/14新特性综述整理
qq_37863891的博客
04-30 590
文章目录右值引用 右值引用 主要作用临时对象非必要的昂贵的拷贝操作，第二个问题是在模板函数中如何按照参数的实际类型进行转发。可以参考 右值引用 主要理解，左值，将亡值，纯右值 左值：所有的具名变量或对象都是左值 将亡值：C++11新增的、与右值引用相关的表达式，比如，将要被移动的对象、T&&函数返回值、std::move返回值和转换为T&&的类型的转换函数的返回值...
C++11/14的新特性(更简洁)
08-26
主要介绍了C++11/14的新特性(更简洁)，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
易语言-C++支持库（充分利用C++11/14新特性编写完成）
06-28
由于论坛缺少好用支持库且易本身C++版本过低导致很多C++新特性无法使用。本次利用C++11/14的标准库以及一些C++知名库（RapidJson，Curl）编写支持库使用，以至于编程上不会太落后。 C++11/14标准库相对于微软类库而...
C++支持库（充分利用C++11/14新特性编写完成）-易语言
06-13
由于论坛缺少好用支持库且易本身C++版本过低导致很多C++新特性无法使用。本次利用C++11/14的标准库以及一些C++知名库（RapidJson，Curl）编写支持库使用，以至于编程上不会太落后。 C++11/14标准库相对于微软类库而...
C++11和C++14新特性
weixin_30297281的博客
10-14 429
C+11新特性： 　　1.新增auto、decltype关键字，二者相似又有区别　　2.新增char16_t、char32_t、long long int类型　　3.新增constexpr编译时常量表达式　　4.新增default、delete、override、final说明符　　5.新增delegating constructors委托构造函数　　6.新增std::initializer_l...
C++中的Lambda表达式
pikefish的博客
10-15 121
C++中的Lambda表达式 #include using namespace std; int main() { int a = 1; int b = 2; auto func = [=, &amp;b](int c)-&gt;int {return b += a + c;}; return 0; } 简单来说，Lambda函数也就是一个函数，它的语法定义如下： capture mutable...
c++11& C++14新特性
jaccen的专栏
01-17 419
阅读目录 Lambda函数 constexpr 类型推导 C++11：C++11包括大量的新特性：包括lambda表达式，类型推导关键字auto、decltype，和模板的大量改进。 新的关键字 auto C++11中引入auto第一种作用是为了自动类型推导 auto的自动类型推导，用于从初始化表达式中推断出变量的数据类型。通过auto的自动类型推导，可以大大简化我们的编程工作 a...
倍加福ENA58IL-R-ProfiNET手册(译文)
07-11
本手册描述了配备PROFINET接口的Pepperl+Fuchs绝对旋转编码器如何集成到PROFINET网络中。 本手册适用于以下绝对旋转编码器类型： ■■Exx58N-...PN... ■Exx58N-。。。请注意。。。 ■■ENA58IL-...B17 ■ENA58IL-。。。B17
框架完整论文答辩PPT模板 (2)
07-11
【作品名称】：框架完整论文答辩PPT模板 (2) 【适用人群】：适用于希望学习不同技术领域的小白或进阶学习者。可作为毕设项目、课程设计、大作业、工程实训或初期项目立项。
手持式DR设备，全球前8强生产商排名及市场份额调研数据.pdf
07-11
QYResearch是全球知名的大型咨询公司，行业涵盖各高科技行业产业链细分市场，横跨如半导体产业链（半导体设备及零部件、半导体材料、集成电路、制造、封测、分立器件、传感器、光电器件）、光伏产业链（设备、硅料/硅片、电池片、组件、辅料支架、逆变器、电站终端）、新能源汽车产业链（动力电池及材料、电驱电控、汽车半导体/电子、整车、充电桩）、通信产业链（通信系统设备、终端设备、电子元器件、射频前端、光模块、4G/5G/6G、宽带、IoT、数字经济、AI）、先进材料产业链（金属材料、高分子材料、陶瓷材料、纳米材料等）、机械制造产业链（数控机床、工程机械、电气机械、3C自动化、工业机器人、激光、工控、无人机）、食品药品、医疗器械、农业等。 邮箱：market@qyresearch.com
大学生创业计划书(16)三套材料.doc
最新发布
07-11
大学生创业计划书(16)三套材料.doc
大学生创业计划书(4)三份资料.docx
07-11
大学生创业计划书(4)三份资料.docx

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值