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

以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持我们。

(0)

相关推荐

  • 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";

  • JDK 14的新特性:文本块Text Blocks的使用

    说起来,Text Blocks是在JDK13中以第一次预览版本引入的.现在在JDK14中是第二次预览版本 JEP 368: Text Blocks. 在我们日常的工作中,有时候需要用到一大段的字符串,这些字符串需要换行,需要排版,需要转义.在一个文本编辑器中,这当然是非常容易的事情.但是在java代码中,就是一个噩梦了. 虽然IDE可以自动帮我们加上换行甚至可以对字符串进行拼接.但在java程序眼中,添加的诸多额外的代码破坏了代码的美感.是任何一个有洁癖的程序员都无法忍受的. 怎么办? Text

  • 关于iOS 11的一些新特性适配实践总结

    前言 iOS 11 已经发布了一段时间了,随手记团队也早早的完成了适配.在这里,我们做了点总结,与大家一起分享一下关于 iOS 11 一些新特性的适配. UIView & UIViewController Layout Margins iOS 11 中,官方提供了一种新的布局方法--通过 layout margins 进行布局.官方文档 Positioning Content Within Layout Margins 称,使用这种布局可以保证各个 content 之间不会相互覆盖. 总的来说,

  • C++14新特性的所有知识点全在这

    前面程序喵介绍过C++11的新特性,在这里(),这篇文章介绍下C++14的新特性. 函数返回值类型推导 C++14对函数返回类型推导规则做了优化,先看一段代码: #include <iostream> using namespace std; auto func(int i) { return i; } int main() { cout << func(4) << endl; return 0; } 使用C++11编译: ~/test$ g++ test.cc -st

  • JDK14的新特性NullPointerExceptions的使用

    JDK 14的新特性:更加好用的NullPointerExceptions 让99%的java程序员都头痛的异常就是NullPointerExceptions了.NullPointerExceptions简称NPE,它是运行时异常的一种,也是java程序中最最容易出现的异常. 出现了NullPointerExceptions之后我们怎么处理呢? 一般情况下就是看日志,看一下到底哪一行出错了.如果这一行只有简单的代码,那么很容易就找到问题所在. 要命的是如果这一行很复杂,那么找出问题就不是那么容易

  • JDK14的新特性:instanceof模式匹配的使用

    JDK14在2020年的3月正式发布了.可惜的是正式特性只包含了最新的Switch表达式,而Records,patterns,text blocks仍然是预览特性. 本文要讲的就是JDK14的一个预览特性instanceof的pattern matching. 也就是说在instanceof中可以使用模式匹配了. 怎么理解呢? 我们先举个历史版本中使用instanceof的例子. 假如我们是动物园的管理员,动物园里面有Girraffe和Hippo两种动物. @Data public class

  • Java 11 正式发布,这 8 个逆天新特性教你写出更牛逼的代码

    美国时间 09 月 25 日,Oralce 正式发布了 Java 11,这是据 Java 8 以后支持的首个长期版本.非常值得大家的关注,可以通过下面的地址进行下载: https://www.oracle.com/technetwork/java/javase/downloads/jdk11-downloads-5066655.html 为什么说是长期版本,看下面的官方发布的支持路线图表. 可以看出 Java 8 扩展支持到 2025 年,而 Java 11 扩展支持到 2026 年. 现在大部

  • C++11的新特性简单汇总介绍 (一)

    什么是C++11 C++11是曾经被叫做C++0x,是对目前C++语言的扩展和修正,C++11不仅包含核心语言的新机能,而且扩展了C++的标准程序库(STL),并入了大部分的C++ Technical Report 1(TR1)程序库(数学的特殊函数除外). C++11包括大量的新特性:包括lambda表达式,类型推导关键字auto.decltype,和模板的大量改进. 1. 概述 最近在看C++ Primer5 刚好看到一半,总结一下C++11里面确实加了很多新东西,如果没有任何了解,别说自己

  • C++11新特性中auto 和 decltype 区别和联系

    C++11新特性中auto 和 decltype 区别和联系 一. auto简介 编程时候常常需要把表达式的值付给变量,需要在声明变量的时候清楚的知道变量是什么类型.然而做到这一点并非那么容易(特别是模板中),有时候根本做不到.为了解决这个问题,C++11新标准就引入了auto类型说明符,用它就能让编译器替我们去分析表达式所属的类型.和原来那些只对应某种特定的类型说明符(例如 int)不同.auto 让编译器通过初始值来进行类型推演.从而获得定义变量的类型,所以说 auto 定义的变量必须有初始

  • C++ 11和C++98相比有哪些新特性

    C++11标准提供了许多有用的新特性.这篇文章特别针对使C++11和C++98相比看上去像一门新语言的特性,因为: C++11改变了书写C++代码的风格和习惯,也改变了设计C++库的方式.例如,你会看到更多的被当作参数和返回值的智能指针,还有按值(by value)返回巨大对象的函数. 它们被使用的非常广泛,在大多数代码中你都能看到它们.举个例子,在现代C++中几乎每5行C++代码你就能看到auto关键字. 还有一些其它的非常好的C++11新特性,但先把这篇文章所描述的新特性熟悉起来把,因为这些

随机推荐