新的字符串表示方式——原生字符串(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 ;
}

C++11/14的新特性——更简洁的更多相关文章

  1. Java 15 正式发布, 14 个新特性,刷新你的认知!!

    JDK 15 2020/09/15 如期而至! 这个时间牛逼啊,和苹果发布会同天? OracleJDK 15 发布地址: https://www.oracle.com/java/technologie ...

  2. (数据科学学习手札139)geopandas 0.11版本重要新特性一览

    本文示例代码已上传至我的Github仓库https://github.com/CNFeffery/DataScienceStudyNotes 1 简介 大家好我是费老师,就在几天前,geopandas ...

  3. JDK 14的新特性:更加好用的NullPointerExceptions

    JDK 14的新特性:更加好用的NullPointerExceptions 让99%的java程序员都头痛的异常就是NullPointerExceptions了.NullPointerExceptio ...

  4. JDK 14的新特性:instanceof模式匹配

    JDK 14的新特性:instanceof模式匹配 JDK14在2020年的3月正式发布了.可惜的是正式特性只包含了最新的Switch表达式,而Records,patterns,text blocks ...

  5. Mysql8.0.11简介,新特性

    MySQL 8.0 正式版 8.0.11 已发布,官方表示 MySQL 8 要比 MySQL 5.7 快 2 倍,还带来了大量的改进和更快的性能! 注意:从 MySQL 5.7 升级到 MySQL 8 ...

  6. RAC 11.2的新特性

    网格即插即用(GPnP) 网格即插即用帮助管理员来维护集群,以前增加或删除节点需要的一些手动操作的步骤现在可以由GPnP来自动实现. GPnP不是一个单独的概念,它依赖于以下特性:在一个XML配置文件 ...

  7. Java 9的14个新特性总结

    Java 9 包含了丰富的特性集.虽然Java 9没有新的语言概念,但是有开发者感兴趣的新的API和诊断命令. 我们将快速的,着重的浏览其中的几个新特性:  模块化系统–Jigsaw 项目 模块化是一 ...

  8. jdk 9 10 11 12 13 新特性

    jdk 9 新特性 1.集合加强 jdk9 为所有集合(List/Set/Map)都增加了 of 和 copyOf 方法,用来创建不可变集合,即一旦创建就无法再执行添加.删除.替换.排序等操作,否则将 ...

  9. kafka 幂等生产者及事务(kafka0.11之后版本新特性)

    1. 幂等性设计1.1 引入目的生产者重复生产消息.生产者进行retry会产生重试时,会重复产生消息.有了幂等性之后,在进行retry重试时,只会生成一个消息. 1.2 幂等性实现1.2.1 PID ...

随机推荐

  1. 偏函数应用 pfa

  2. cocos2d-js添加百度appx的插屏广告(通过jsb反射机制)

    本来一直用的anysdk接入广告,结果从前几天开始,百度商店的审核总是通不过,结果一问才知道:要上传到百度商店就必须要用百度的appx(真的是各种坑,我们这些个人开发者迟早要被你们大公司玩死),没办法 ...

  3. mysql系列之2.mysql多实例

    使用场景 资金紧张; 并发访问不大; 门户网站; 实现 生产硬件配置: mem 32G / 双cpu 8核 / 磁盘6*600G sas 15k, 2-3个实例 安装组件 #yum install n ...

  4. 基础学习笔记之opencv(6):实现将图片生成视频

    基础学习笔记之opencv(6):实现将图片生成视频 在做实验的过程中.难免会读视频中的图片用来处理,相反将处理好的图片又整理输出为一个视频文件也是非经常常使用的. 以下就来讲讲基于opencv的C+ ...

  5. Java for LeetCode 137 Single Number II

    Given an array of integers, every element appears three times except for one. Find that single one. ...

  6. Quartz Job scheduling 基础实现代码

    Quartz 集成在 SpringBoot 中分为 config.task.utils.controller 和 MVC 的三层即 controller.service.dao 和 entity. c ...

  7. javascript 跨浏览器事件处理

    <div id="myDiv" style="width:100px; height:100px; border:1px solid #f00;"> ...

  8. GDB调试core文件(2)

    使用gdb和core dump迅速定位段错误 关键字:gdb.段错误.core dump 一.什么是core dump core:内存.核心的意思: dump:抛出,扔出: core dump:前提: ...

  9. 用ant编译打包时 警告:编码 GBK 的不可映射字符

    原因,参考http://zhidao.baidu.com/question/26901568.html 添加如下的红色一行后编译通过<target name="compile" ...

  10. Protothread 机制

    一.概述 很多传感器操作系统都是基于事件驱动模型的,事件驱动模型不用为每个进程都分配一个进程栈,这对内存资源受限的无线传感器网络嵌入式系统尤为重要. 然而事件驱动模型不支持阻塞等待抽象语句,因此程序员 ...