什么是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++ Primer5是學習C++11的比較好的書籍。這篇文章僅總結關于C++11中的新東西，老的東西不再贅述。本文的所有代碼僅僅值列出關鍵代碼，并且所有特性都已經用編譯器驗證過，我的編譯環(huán)境 gcc 5.3.1  g++ 5.3.1 ，據說 4.7以上的版本已經支持大部分C++11的特性，VS系列的編譯器對C++11的支持情況不甚了解，如果沒有合適的編譯器，可以點擊這里 C++shell 這是一個在線的C++編譯系統(tǒng)，里面有多個選項可以選擇C++98，C++11，C++14等，可以在這里面驗證C++11的正確性。

2. long long 類型

long long 類型實際上沒有在C++ 98中存在，而之后被C99標準收錄，其實現在市面上大多數編譯器是支持 long long 的，但是這個類型正式成為C++的標準類型是在C++11中。標準要求long long至少是64位也就是8個字節(jié)。一個字面常量使用LL后綴表示long long類型，使用ULL后綴表示unsigned long long 類型。

3. 列表初始化

C++11中全面加入了列表初始化的功能，包括對vector，map，值類型，struct等等都可以使用列表初始化，還可以在函數中返回一個花括號括起來的列表，而在這之前我們只能對數組進行列表初始化：

//數組列表初始化
int xx[5]={1,2,3,4,5};
int yy[]={6,7,8,9,0};
 
//值類型進行初始化
int a{10};
int b={10};
int c={10.123}; // 編譯器報錯，g++ 5.3.1當列表初始化用于值類型的時候，如果有精度損失，編譯器會報錯。
 
//列表初始化還可以用結構體
typedef struct Str{
  int x;
  int y;
}Str;
Str s = {10,20};
 
//列表初始化類,必須是public成員,如果含有私有成員會失敗
class Cls{
public:
  int x;
  int y;
};
Cls c = {10,20};
 
//vector不僅可以使用列表初始化，還可以使用列表進行賦值，數組不能用列表賦值
vector<int>v1={1,2,3,4,5,6,7,8,9}; // 初始化
vector<int>v2;
v2={3,4,5,6,7}; //賦值
 
//map列表初始化
map<string ,int> m = {
   {"x",1},
   {"y",2},
   {"z",3}
};
 
//用函數返回初始化列表只展示關鍵代碼，相關頭文件自行添加
//同理結構體，類，map的返回也可以使用初始化列表返回
vector<int> getVector()
{
 return {1,2,3,4,5};
}
 
int main()
{
 vector<int> v = getVector();
 cout<<v[0]<<v[1]<<v.size()<<endl;
 return 0 ;
}

4. nullptr 空指針

C++11中新加入的字面值表示不指向任何對象的空指針，以前我們常常用一個預定義的宏NULL來表示空指針，實際上NULL的值是0，新標準推薦使用nullptr而不是NULL

5. constexpr變量

我們在定義常量的時候一般使用const來定義，一個常量必須在定義的時候進行初始化，并且之后不可更改。一個常量必須使用一個常量表達式進行初始化，并且在編譯期間就可以得到常量的值，但是如何確定一個表達式就是常量表達式呢，這個通常是由程序員自己確定的，例如：

const int a =20;
//20是一個字面值，當然也是一個常量表達式，所以用20來為a賦值是沒有問題的
//然而下面的代碼也可以通過編譯，g++ 5.3.1
int a = 20 ;
const int x = a;
int b[x]={0};

為常量x賦值的是一個變量a，這樣做應該是不合理的，但是編譯器沒有報告任何錯誤，當然這種錯誤是顯而易見的，但是在復雜的系統(tǒng)中如何判斷一個表達式是否是常量表達式是很困難的，例如這里的a我們一眼就可以判斷其并不是一個常量表達式。為此C++11提供了一個新的關鍵字constexpr，使用該關鍵字定義的常量，由編譯器檢查為其賦值的表達式是否是常量表達式，例如上面的代碼改成：

int a = 20 ;
constexpr int x = a;

編譯器編譯的時候就會報錯說a并不是常量。顯然constexpr關鍵字將常量表達式的檢查轉交給編譯器處理，而不是程序員自己，所以使用constexpr定義常量要比const安全。

6. constexpr函數

普通的函數一般是不能用來為constexpr常量賦值的，但是C++11允許定義一種constexpr的函數，這種函數在編譯期間就可以計算出結果，這樣的函數是可以用來為constexpr賦值的。定義constexpr函數需要遵守一些約定，函數的返回類型以及所有形參的類型都應該是字面值，一般情況下函數體中必須有且只有一條return語句。

constexpr int size()
{
  return 42;
}
 
constexpr int si = size();

執(zhí)行初始化的時候編譯器將函數的調用替換成結果值，constexpr函數體中也可以出現除了return之外的其他語句，但是這些語句在運行時不應該執(zhí)行任何操作，例如空語句，using聲明等。constexpr函數允許其返回值并非是一個字面值，例如：

constexpr int size(int s)
{
  return s*4;
}
 
int a = 20;
const int b = 30;
constexpr int c = 40;
constexpr int si = size(a); //error a是一個變量所以函數返回的是一個可變的值
constexpr int si1 = size(20); //ok 函數返回的實際上是一個常量
constexpr int si2 = size(b); //ok
constexpr int si3 = size(c); //ok

由上可知constexpr函數并不一定返回常量，如果應用于函數的參數是一個常量表達式則返回常量，否則返回變量，而該函數調用到底是一個常量表達式還是非常量表達式則由編譯器來判斷。這就是constexpr的好處。

7. using類型別名

類型別名其實早在C語言中就有了，一般情況下我們使用關鍵字typedef來聲明一個類型的別名，在C++11中增加了另一種聲明類型別名的方法就是使用using關鍵字，using關鍵字在C++11以前一般用來引用命名空間。

typedef int INT; // 右側符號代表左側
using INT2 = int; // 左側符號代表右側
 
INT a = 20;
INT2 b = 30;

8. auto類型指示符

我們定義一個變量的時候首先必須確定該變量的類型，而很多時候并不是我們先需要一個變量然后為該變量賦值合適的數據，而是我們有一個值但是我們卻不知道該用什么類型的變量存儲它，特別是C++的模版使用的非常廣泛，有時候要定義一個變量，其類型是很復雜的會帶有模版的類型參數，例如一個最常見的例子：

map<string ,int> m ;
map<string,int>::iterator it = m.begin();

上面的例子中我們定義了一個map<string,int>::iterator類型的變量來存放 m.begin()的值,這個例子相對來說還不算困難但是我在開始使用map容器的時候也曾經被搞暈過，如果map是一個 map<string,double> 類型則需要定義一個  map<string.double>::iterator it 來存放了。特別是如果map和vector之間互相嵌套的情況就更容易弄錯了。定義這種類型變量的另一個缺點就是一個類型的名字往往會很長，試想一下程序代碼中通篇都是這種變量聲明，恐怕不會有幾個人看著舒服吧。不過沒關系C++11為我們定義了一個新的關鍵字 auto 用來定義變量，而變量的類型由編譯器自動根據賦值的表達式推導出來，不需要我們顯示定義了。因為auto定義的變量的類型由編譯器根據賦值的表達式推導，所以auto定義的變量必須有初始值，否則編譯器沒法確定該變量的類型。

auto x = 20; // x 是int
auto y = 3.14; // y 是double
map<string ,int> m ;
auto it = m.begin(); //it 是map<string,int>::iterator

這樣是不是方便了不少，而且程序看起來更加簡潔了
auto可以在一條語句中聲明多個變量，但是要保證語句中的基礎數據類型只有一個，例如：

auto i=10,*p=&i; // OK i是int，p是int*
auto a=10,b=3.14; // Error 類型是int還是double ?

9. decltype類型指示符

有時候會有這樣的需求，我們需要知道一個表達式的類型，并使用該類型去定義一個變量，例如：

int a = 10;
int b = 20;
auto c = a + b; // OK a+b的類型是int，此時c的類型是int，并且c的值是 a+b

auto可以解決部分問題，例如我們定義的變量的類型就是表達式 a+b 的類型，但是如果我們僅僅需要定義一個與表達式 a+b 的類型相同的變量，但是我們又不希望將表達式a+b的值賦值給剛剛定義的變量，我們希望賦另外一個值或者是僅僅定義變量而不賦值呢。 這就需要用到C++11 提供的另一個類型說明符 decltype了。decltype作用于一個表達式，并且返回該表達式的類型，在此過程中編譯器分析表達式的類型，并不會計算表達式的值。例如

int a = 10;
int b = 20;
decltype(a+b) c = 50; // OK c的類型就是 a+b 的類型int

對于引用類型decltype有一些特別的地方：

int a = 20 ;
int &b = a;
decltype(b) c ; // Error c是引用類型必須賦值
decltype(b) d = a; // OK d是引用類型，指向a

可以看到decltype如果作用于一個引用類型，其得到的還是一個引用類型。我們知道一個引用類型在使用的時候一般會當作其關聯的那個變量的同義詞處理，例如如果使用 cout<<b<<endl; 其中b實際上相當于a，但是decltype作用于引用類型的時候會保留引用性質。

如果一個表達式是一個解指針引用的操作，decltype得到的也是一個引用類型：

int a = 20 ;
int *p = &a;
decltype(*p) c = a; // c的類型是int&
c = 50;
cout<<a<<endl; // 輸出50

當decltype作用于一個變量的時候，變量加不加括號是有區(qū)別的，例如：

int a = 20;
decltype(a) b = 30; //ok b的類型是 int
decltype((a)) c = a ; // ok c的類型是int& 其關聯變量 a

加上括號之后編譯器會把(a)當作是一個表達式處理，而變量是一種可以作為賦值語句左值的表達式，所以會解釋成引用類型。

最新評論