C++11/14的新特性(更簡潔)

原創 小念之歌 2019-01-24 10:53

這篇文章主要介紹了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;
}

以上就是本文的全部內容，希望對大家的學習有所幫助，也希望大家多多支持神馬文庫。

發表評論
所有評論
還沒有人評論，想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章

Android 5.0新特性

tlw90 2019-02-23 00:37:55

Centos 6.5 監控路由器、思科交換機Nagios (三)

Hellvenus 2019-02-23 00:12:48

與技術談一場永不分手的戀愛

張甦 2019-02-22 22:48:35

Android7.0新特性

kingZXY2009 2019-02-22 22:32:02

JDK1.5新特性

liuyahui5656 2019-02-22 22:26:47

Android4.1 新功能 新特性

jxsmallmouse 2019-02-22 20:06:59

MySQL 5.7.9 GA穩定版新特性解讀

你瞅啥Zz 2019-02-22 18:20:00

JDK5新特性

xxzjzsj 2019-02-22 17:17:41

jdk8新特性之雙冒號 :: 用法及詳解

www19 2019-02-22 16:09:59

mysql5.6主從參數詳解

AIOPS_DBA 2019-02-22 14:59:52

mysql5.5 5.6 5.7新特性

幽魂伊夢 2019-02-22 14:22:36

HTML5新特性總結

葉夢青衫 2019-02-22 13:43:57

Windows Mobile 7 夢幻之旅系列1之- What’s New？

葛涵濤 2019-02-22 13:24:46

java8新特性之Optional的深入解析

Owen Jia 2019-02-06 14:52:49

java8新特性教程之time包使用總結

Owen 2019-02-01 13:13:06