C++剛?cè)腴T,，以下為自己學(xué)習(xí)時整理的資料,，寫出來的是自己的理解，只是想加深自己的印象和以后方便自己查閱,，可能有不正當(dāng)?shù)牡胤健?br>
1,、新增算術(shù)類型
     longlong，最小不比long小,，一般為64位,。

2、列表初始化
      int units_sold = {0};或者 int units_sold{0};非11標(biāo)準(zhǔn)下的C++中,，只有特定的情況下才能使用該形式,。  比如數(shù)組的初始化，類構(gòu)造函數(shù)的初始化,，結(jié)構(gòu)體的填充,。相比傳統(tǒng)的賦值初始化，如果右側(cè)的數(shù)值類型相對于左側(cè)類型更大的話,，側(cè)對于這種窄化現(xiàn)象,，編譯器會 報錯。如：int k = {3.14};一個double是8個字節(jié),，int一般是4個字節(jié),，這時編譯器就會報錯,。

      在容器中，也支持這種方法,，比如std::map容器,，比如我們定義一個std::map<string,int> m_map，以前我們需要對它進(jìn)行插入,，一般做法是 m_map.insert(value_type("test",1));,這樣用一個函數(shù)來生成pare<string,int>再進(jìn)行插入,但現(xiàn)在有種更方便的方法,，讓我們能在初始化時進(jìn)行賦值，像下面這樣：

map<string,int> m_map = {{"test",1},{"test2",2}};

     每一組值都用{}括起來,，跟列表初始化使用上是一致的,。

5、nullptr常量
       其實(shí)這個常量跟NULL一樣,，都是0值,，只是NULL是預(yù)處理變量，在C++11中,，應(yīng)該盡量減少NULL的使用,。宏定義往往會導(dǎo)致非程序員本身需要的目 的（大部分是運(yùn)算符優(yōu)先級問題，比如#define duplicate(x) x*x,如果你是想算兩個x+1后的結(jié)果再相乘,，如果你寫成duplicate(x+1),編譯器展開后會是 x+1*x+1,這樣明顯與原來的意圖完全不同）,，而且，排除稍困難,，一般來說,，都會盡量避免使用。

6,、constexpr
      constexpr可以說是對const變量的擴(kuò)展,，它只是約束const變量的右側(cè)的式子必須能在編譯時就能算出值。要理解這點(diǎn),，我們首先要搞清楚 const和constexpr之間的同異處.首先,，無論是constexpr或者const變量，值都是定義后不能改變的,，而且,，它們等號右側(cè)同樣都可 以為一個表達(dá)式；兩者的一個很重要的區(qū)別是const常量能在運(yùn)行時獲得值,，而constexpr卻是帶有約束性質(zhì)的,，它約束右側(cè)的式子只有在編譯時就能 算出值，如果不能的話,，編譯器側(cè)會報錯,。比如：const int max = 20; const int limit = max + 1;它們都是一個const變量同時，右側(cè)也是一個常量表達(dá)式,。但const int sz = str.size();它是一個在運(yùn)行時取得具體值的const變量,，但在編譯時卻無法取得具體值，所以右側(cè)的表達(dá)式明顯不是一個常量表達(dá)式,。往往程序員 希望某一變量必須是常量以防止在運(yùn)行過程中產(chǎn)生非意料之外的值（該過程大都由粗心導(dǎo)致的疏忽）,，所以C++11中才會加入一個新的constexpr關(guān)鍵 字，這樣的話,，當(dāng)定義constexpr int sz = str.size();時,，就會由編譯器發(fā)出提示,，而避免上述情況的發(fā)生。

7,、constexpr函數(shù)

     constexpr函數(shù)是指能用于常量表達(dá)式的函數(shù),。比如上面的如果constepr int size = size() + 1;成立的話，size(int max)就是一個constexpr函數(shù),它定義或者如果下：

          int size() { return 30;}

     對于constexpr函數(shù),，有以下幾點(diǎn)需要注意：

     1）constexpr只能有一個return;

     2）因?yàn)樾枰诰幾g時展開constexpr函數(shù),，所以constexpr函數(shù)默認(rèn)為inline函數(shù)。

     3）主要語句不會在運(yùn)行時被執(zhí)行（注意,，是運(yùn)行時不會被執(zhí)行,，別想著a = 1;這種也算，這是運(yùn)行時才被執(zhí)行的語句,，是無法通過的,，說到底，只有第4點(diǎn)的語句才會合法）,，constexpr函數(shù)體內(nèi)可包含任意數(shù)量語句,。

     4）constexpr函數(shù)體內(nèi)可以包括空語句，類型別名和using聲明,，主要是編譯能執(zhí)行的語句都可以,。

     本質(zhì)上，constexpr函數(shù)跟constexpr表達(dá)式一樣,，只是用于編譯時進(jìn)行常量檢測,。

8、constexpr構(gòu)造函數(shù)

      在說這個前,，我們應(yīng)該要注意的重要的一點(diǎn)是：constexpr構(gòu)造函數(shù)無論名稱怎么變,，但它仍然需要遵守constexpr函數(shù)的規(guī)則。這些規(guī)則總結(jié)為以下幾點(diǎn)：

1）constexpr構(gòu)造函數(shù)可以聲明為=default或者刪除函數(shù)的形式,。前者相當(dāng)于編譯器合成的默認(rèn)構(gòu)造函數(shù),，一般情況下幾乎不執(zhí)行任務(wù)初始化工作，所以不會與constexpr函數(shù)的約束沖突,；后者相當(dāng)于屏蔽類的某個功能,，現(xiàn)在先不用管，后面會提到,。

2）對于第1種情況外的constexpr構(gòu)造函數(shù),，constexpr的限制就比較多了:它既要滿足構(gòu)造函數(shù)的限制條件，也必須得滿足自身的限制條件,。前者讓它不能有返回語句（構(gòu)造函數(shù)是沒有返回值的）,，后者限制了函數(shù)體內(nèi)的內(nèi)容必須是能在編譯時確定的，也即是說,，除了返回語句外其它語句都不成立（當(dāng)然還可以有類型別名之類的語句,，但這些語句真的想不出有什么必要聲明在一個構(gòu)造函數(shù)中），所以通常它的函數(shù)體都是空的,。

3）constexpr構(gòu)造函數(shù)必須初始化所有數(shù)據(jù)成員,，而且初始值只能是常量，比如一個constexpr函數(shù)的委托構(gòu)造函數(shù)的形式或者一條常量表達(dá)式,。

// 如C++ Primer中的例子

class Debug

{

     public:

          constexpr Debug(bool b = true):hw(b),io(b),other(b){}

          constexpr Debug(bool n,bool i,bool o):hw(h),io(i).other(0){}

private:

      bool hw,io,other;

}

可以看出,，初始化列表中的變量都是常量，true和false都是常量表達(dá)式,。如果是int類型,，如果賦值是一個字面常量也是可以的，初始化列表中的右值主要是常量表達(dá)式都是正確的,。

9,、類型別名
     類型別名是C和C++一樣存在的，以前的typedef的用法為typedef typeA typeB,，把typeA定義為typeB的一個別名,，這種用法，更像是宏定義的用法,，并沒有等號表達(dá)式直觀,；C++11中新增一種定義類型別名的方法， 該方法更符合我們平時的使用習(xí)慣：using typeA = typeB;這種方法在平時可能并無法表現(xiàn)多大的優(yōu)越性,，但如果用于函數(shù)指針時,，卻是很直觀的。比如有如下函數(shù) int add(int a,int b);如果定義指針,，以前的做法是typedef int (add*)(int a,int b);這種語法,，對于新手來說，是很難理解的,，如果再復(fù)雜點(diǎn),，返回值還是一個函數(shù)指針的話，那更難以理解了,。新手一種會按我們上面說的那種基本語法去理 解,，typedef typeA typeB,一個函數(shù)指針，很難找出那部分是對應(yīng)typeA,那部分是對應(yīng)typeB,，事實(shí)上,，typeA就是add,它可以是任何名稱，只是我這里剛好 與函數(shù)名是一樣而已,，如果寫作typedef int (addptr*)(int a,int b);你就會知道,，定義一個函數(shù)指針與函數(shù)名完全無關(guān)，而只是與返回類型和參數(shù)類型有關(guān)（甚至可以沒有參數(shù)名稱：typedef int (add*)(int,int);）,，但無論怎么說,，這種方法仍然是不太直觀的,，現(xiàn)在C++11中可以 這樣用了。
using addptr = int (int,int);它很明確指出,，addptr就是一個函數(shù)指針,，它指向的函數(shù)類型為：返回值是int,并帶有兩個int形參的所有函數(shù)。

10,、auto類型
     auto是C++11中新增加的特性,，對于我們平時編寫代碼，我建議是少用應(yīng)該盡量少用,，只有在寫代碼時知道我每步會產(chǎn)生的結(jié)果時才會寫出健壯的程序,，僅 auto來為我們判斷類型，事實(shí)與我們靜態(tài)語言的原意相悖了,；auto更多應(yīng)用于泛型編程中,，它能減少你編寫特化模板的工作量。對于auto,，我們只需要 記住以下幾點(diǎn)：
1）auto是編譯時得到的類型,，也就是說，它是讓編譯器替我們分析表達(dá)式所屬的類型的,，所以有時候auto產(chǎn)生的值,，如果對它沒有足夠的理解，你會被弄糊涂,。
2）auto只能推斷一種類型,，比如當(dāng)一條語句中聲明多個變量時，如果變量類型不同,，是會產(chǎn)生錯誤的：auto sz = 0,pi = 3.14;一個為int型,，一個為double型，這時auto是不能正常工作的,。
3） 當(dāng)右值是一個引用類型時,，auto的類型不是一個引用類型，而是引用類型的值,。比如double &PI = pi;auto ref = PI;ref的類型不是double&而是跟pi的類型一樣,，為一個double類型。當(dāng)我們確實(shí)需要一個引用類型時,，我們可以寫成這樣auto &ref = PI;
4）說這點(diǎn)前,，先說明下C++ Primer中提到的頂層const和底層const的概念。當(dāng)一個const變量自身無法改變時,，我們稱為頂層const,，當(dāng)一個const變量本身可 改變，但關(guān)聯(lián)的變量無法改變時我們稱為底層const。也即是頂層也就是表面,，底層也就是表面掩住的內(nèi)容,。如果:const double pi = 3.14;double *const ptr = &pi;(注意,不要寫成double const *ptr,這個是跟const double* ptr一樣的)， 這 2個都是頂層const,，他們本身的值無法改變;const double *ptr2 = &pi;;const double PI = &pi;這2個都是底層const,，事實(shí)上，指向常量的指針和聲明引用的const都是底層const;  auto會忽略掉頂層const的性質(zhì),，但保留底層const;比如auto x = pi;這時x的類型為double而非const double,，同樣地,，當(dāng)auto x = ptr時,，x的類型為double*;而auto x = ptr2，此時的x為const double*類型,，它說明指向的值不可改變,。如果我們想保留頂層const，只能手動寫上符號,如auto const x = &pi;
總的來說,，auto能判斷內(nèi)置類型,，能判斷指針類型，但卻無法正確判斷出引用類型和頂層const類型,，對于頂層const類型和引用類型(所有的const引用類型都是頂層const類型)只能通過手動增加的方法保留特性,。

5）由編譯器確定動態(tài)分配數(shù)據(jù)的類型，C++11的auto在new中也有新的定義,，之前我們必須確實(shí)地指定new類型和指針類型才能正確地在堆上分配內(nèi)存空間,，現(xiàn)在，C++11允許由編譯器推斷分配類型,，用法如下：

auto p1 = new auto(std::string); // p1為指向string類型的指針

11,、decltype
      我覺得C++11新增的這個特性，比auto更奇葩,，要理解這個東西,，說真的，難度不是一般的大,，說不得,，真想深入研究，你應(yīng)該重新翻翻編譯原理,。以下幾點(diǎn),，是我們必須注意的：
1）decltype是推斷類型的，它允許變量和表達(dá)式,，但無論是那一種,，它都忽略值而只關(guān)注類型的,，比如表達(dá)式,，并不會調(diào)用表達(dá)式而只是推斷當(dāng)表達(dá)式被調(diào)用時,，會返回一個什么樣的類型,。
2）decltype 在處理頂層const跟auto不同，它返回的類型是包括頂層const的，也就是說當(dāng)double *const ptr = &pi;時auto x = ptr;類型是double* ，但如果用decltype(ptr)得到類型卻是完整的double *const類型,。對于引用,，也是一樣的,。但引用必須注意,，如果const int &x = pi;decltype(x)后得是必須要初始化的,，因?yàn)橐妙愋捅仨毝x的同時初始化。
3）注意這種情況：decltype(x + 0)——這里我們假定x是int&類型,引用類型進(jìn)行decltype是作為一條賦值語句的左值的,。最后的結(jié)果應(yīng)該是int類型,。
4） 這點(diǎn)是最重要的：加不加括號,，我們得到的類型可能是會不同的,。比如int i = 0;當(dāng)我們調(diào)用decltype(i)時,，這很容易理解，得到的類型肯定是int類型,；但如果我們加上一重或多重括號如：decltype((i)),，我 們得到的是int&類型。事實(shí)上,，變量也是可以作為一種賦值語句左值的特殊表達(dá)式,，從C++的初始化就可以看出,比如int i(0);，可以看出,，這是一個函數(shù)調(diào)用的形式,，事實(shí)上，這個比較難理解,，我也不明白,，而這也僅僅是一個數(shù)學(xué)到的概念而已，a+b = 0是代數(shù)式,，那a和b都是代數(shù)式,。反正decltype是C++11新增的機(jī)制。

5) decltype可用于返回類型：比如下面這段代碼：（選自C++ primer）

   int odd[] = {1,3,5,7,9};

   int even[] = {0,2,,4,,6,8};

 // 返回一個指針,，該指針指向含有5個整數(shù)的數(shù)組

 decltype(odd) * arrPtr(int i)

{

    return (i%2) ? &odd:&even; // 返回一個指向數(shù)組的指針

}

 這里是特別需要注意的,，函數(shù)的返回的是數(shù)組的地址，但decltype(odd)得到的類型卻是一個含有5個元素的數(shù)組,，它不會幫我們把數(shù)組轉(zhuǎn)換成指針類型,，所以還要在addPtr前加上*表示返回類型的是一個指向含有5個元素的數(shù)組的指針,。

      主要是我們記住,，如果加了括號，declstype的類型永遠(yuǎn)是引用,。最后總結(jié)是,，這樣的：
如果e是一個沒有外層括弧的標(biāo)識符表達(dá)式或者類成員訪問表達(dá)式，那么decltype(e)就是e所命名的實(shí)體的類型,。
如果e是一個函數(shù)調(diào)用或者一個重載操作符調(diào)用（忽略e的外層括?。敲磀ecltype(e)就是該函數(shù)的返回類型,。
否則,，假設(shè)e的類型是T：若e是一個左值，則decltype(e)就是T&,；若e是一個右值,，則decltype(e)就是T。

    
12,、范圍for
     看C#,，JAVA,，都有for...each語法，javaScript有for...in語法,，OC也有自己的迭代遍歷語法,，總的來說，對于特定的數(shù)據(jù) 的遍歷,，這些方法確實(shí)足夠簡單,，但說真的，這些方法方便的地方在于能動態(tài)判斷類型,，但我個人認(rèn)為,，這種范圍for對于C++來說，作用真不算強(qiáng)大,，因?yàn)? C++不像C#這些一樣,，一個數(shù)組內(nèi)能混合不同的類型，C#的同一個數(shù)組內(nèi)能加入基本類型,，也能加入類類型,，但C++只能加入特定一種類型，所以,，每個數(shù) 組都是特定類型,，用auto其實(shí)作用不大，而傳統(tǒng)的for語句,，跟使用范圍for相比,，并沒有多大的不方便吧。
C++11新加入for(auto value:data);

13,、cbegin()和cend()【容器】
     傳統(tǒng)的C++中，標(biāo)準(zhǔn)庫中的所有容器都有begin()和end()函數(shù),，分別取得容器的首元素和最后元素的下一次位置,。但以上兩個函數(shù)，返回的都是 iterator類型,。而新增加的cbegin()和cend()函數(shù),，返回的是const_iterator類型。

14,、beign()和end()【標(biāo)準(zhǔn)庫】
     比如有如下數(shù)組：
     int arr[] = {1,2,3,4,5,.........};
     傳統(tǒng)C++要遍歷會作出如下操作：
     for(int i = 0; i != sizeof(arr) / sizeof(arr[0]); ++i){};
     或者
     for(int *p = arr[0]; p != arr[0] + sizeof(arr) / sizeof(arr[0]; ++i){};
     前者在某種程度上是安全的,，但對于后者，要取得有效數(shù)據(jù)的下一個位置時,，卻是極易出錯的,。所以，為了讓指針操作更安全,，C++11提供了begin()和end()函數(shù),，分別指向數(shù)據(jù)的起始和結(jié)束位置的下一位置【他們都是指針類型】,。我們現(xiàn)在可以更安全地遍歷數(shù)組等數(shù)據(jù)了：
     for(int *p = begin(arr); p != end(arr); ++p){};
甚 至，這兩個函數(shù)也提供了跟迭代器一樣的操作,，退兩個迭指針相減的結(jié)果就是它們之間的與數(shù)據(jù)類型相關(guān)的距離,，比如，arr如果有5個元素,，則auto diff = end(arr) - begin(arr),diff的值為5,，而且，diff的類型是標(biāo)準(zhǔn)庫類型ptrdiff_t,，這是一種帶符號的類型,，因?yàn)椴钪悼赡軙樨?fù)數(shù)。

15,、initializer_list類
     傳統(tǒng)的可變參數(shù)一般是用va_list的一組宏來解決的?，F(xiàn)在，C++11新增了模板類initializer_list,，在便利性上得到提升,。它跟 va_list最大區(qū)別是，va_list中的va_arg的參數(shù)可以為任意類型,，但 initilizer_list只允許未知的形參使用相同的類型,。
     對于initializer_list，一個最重要的概念是,，initializer_list內(nèi)所有的元素都是常量,，這與vector這些容器是不一樣的。
     initializer_list因?yàn)橛幸环N構(gòu)造方法為initializer_list<T> lst{a,b,c.....};使得它可以實(shí)現(xiàn)可變參數(shù)（我知道,，vector,，list一樣可以這樣做，但問題是,，vector和list總是一開始 就分配內(nèi)存空間的,，相比較下，initializer_list是輕量級的,。PS:這貨不支持下標(biāo)操作的，只能用指針,，或者在標(biāo)準(zhǔn)庫中叫迭代器更好點(diǎn)）,，大概方法如下:
void CoutList(initializer_list<string> il)
{
   // 一般為了方便，我們不清楚il.begin()的類弄,，可以 用auto代替,，但事實(shí)上， begin返回的是一個以模板實(shí)例相同  的const類型,。
    for(auto beg = il.begin(); beg != il.end(); ++beg)
｛
     cout << *beg << endl;
｝
調(diào) 用時可以這樣,，CoutList({"1","2","3"});,，相較傳統(tǒng)的va_list宏而言，這種方法雖然簡結(jié)了,，但對于傳統(tǒng)的C++程序員來 說,，多了個花括號，可能已經(jīng)不算正規(guī)的函數(shù)調(diào)用了,。不過,，它為我們提供了一種方法，如果上面的函數(shù),，用va_list是無法達(dá)到的,，原因就 是，va_list必須至少帶一個參數(shù),，以作為va_start的起始點(diǎn),，上面的函數(shù)，我們可以增加一個表示傳入?yún)?shù)數(shù)量的形參,，可以可以這樣寫：
void CountList(int nNumber,...)
{
     va_list lt;  //定義一個 va_list 參數(shù)表
     va_start(lt,nNumber);  // 初始化va_list,，并讓其指針指向參數(shù)表中的第一個參數(shù)

     // 因?yàn)槭菞＃詶５拙褪堑谝粋€參數(shù),，+1是從棧頂向棧低取值,，用第一個參數(shù)判斷循環(huán)結(jié)束是可以的
     for(int i = 0; i != nNumber; ++i)
     {
         // 取得參數(shù)表中的第i個參數(shù)，總設(shè)置string類型,，此時lt會自動指向當(dāng)前位置的下一位置（ap是先移動一個位置再返回值的,。）
          string tmp = va_arg(lt,string); 
          cout << tmp << endl;
     }

     va_end(lt); // 用完清空是好習(xí)慣
}
調(diào)用時可以用如下方法：CoutList(3,"1","2","3");

#define _INTSIZEOF(n)   ( (sizeof(n) + sizeof(int) - 1) & ~(sizeof(int) - 1) )  // 這個是字節(jié)對齊，自己參考文檔,。（http://yangtaixiao.blog.163.com/blog/static/42235441201441233325695/）

#define _crt_va_start(ap,v)  ( ap = (va_list)_ADDRESSOF(v) + _INTSIZEOF(v) )
#define _crt_va_arg(ap,t)    ( *(t *)((ap += _INTSIZEOF(t)) - _INTSIZEOF(t)) )
#define _crt_va_end(ap)      ( ap = (va_list)0 )

       class B
       {
           private: 
                int Size = 0;
                std::vector<int> vt{1,2,3};
       };

      class A
      {
       public:
             A(int size):iSize(size){}
             A():A(30)
            {
                 area = 90;
            }
      private:
             int iSize;
             double area;
      };

class em
{
   public:
           em(string name,int age,bool sex)
           {
                  m_name = name;
                  m_age = age;
                  m_sex = sex;
           }
  private:
          string m_name;
          int m_age;
          bool m_sex;
};

     int GetBiger(double first, double second)
     {      
             double result = (first > second) ? first : second;
             auto func = []{return result; };
             return func();
     }

    int GetBiger(double first, double second)
     {      
             double result = (first > second) ? first : second;
             auto func = [result]{return result; };
             return func();
     }

   void func()
   {
        size_t v1 = 42; // 函數(shù)內(nèi)局部臨時變量
        // 捕獲列表為值捕獲,在創(chuàng)建lambda時(生成類時調(diào)用構(gòu)造函數(shù))就已經(jīng)拷貝
        auto f2 = [v1]{return v1;}; 
        v1 = 0;
       auto j = f2();  
   }

void func()
   {
        size_t v1 = 42; // 函數(shù)內(nèi)局部臨時變量
        auto f2 = [&v1]{return v1;}; // 在創(chuàng)建lambda時時引用類型，格式為引用符號寫在捕獲變量前面
        v1 = 0;
       auto j = f2();  
   }

   void func()
   {
        size_t v1 = 42;
        auto f2 = [=]{return v1;};  // 值捕獲
        v1 = 0;
       auto j = f2();  
   }  

   void func()
   {
        size_t v1 = 42;
        auto f2 = [&]{return v1;}; // 引用捕獲
        v1 = 0;
       auto j = f2();  
   }  

    void func()
   {
        size_t v1 = 42; 
        size_t v2 = 30;
        auto f2 = [&,v2]{return v1 + v2;}; // 混合使用隱式和顯示捕獲
        v1 = 0;
       auto j = f2();  
   }   

   void func()
   {
        size_t v1 = 42;
        auto f2 = [v1]{return ++v1;}; // 值捕獲
        v1 = 0;
       auto j = f2();  
   }  

   void func()
   {
        size_t v1 = 42;
        auto f2 = [v1] () mutable {return ++v1;}; // 值捕獲
        v1 = 0;
       auto j = f2();  
   }  

   void func()
   {
        const size_t v1 = 42;
        auto f2 = [&v1] {return ++v1;}; //引用捕獲
        v1 = 0;
       auto j = f2();  
   }   

class CC
{
public:
    CC() {}
    ~CC() {}
private:
    int a = 7; // 類內(nèi)初始化,，C++11 可用
}

struct ST
{
	int a = 0; // 聲明時就必須要定義
	static int b;
};
cout << sizeof(ST::b) << endl; // 靜態(tài)成員本來就是這樣取值的,，所以跟新的有沖突,，只有非staic可以
cout << sizeof(hasY::a) << endl; // 直接由hasY型別取得非靜態(tài)成員的大小,，C++03不行,。 C++11允許

class test
{
public:
  test() {} = delete; 
  test(const test&) = delete; // 拷貝構(gòu)造函數(shù)
  test& operator=(const test&) = delete; // 拷貝賦值運(yùn)算符
 ~test() = delete; // 析構(gòu)函數(shù) 
};

class hasY
{
public:
	hasY() = default;
	hasY(const hasY&)
	{
		cout << "copy" << endl;
	}

	hasY& operator=(const hasY&)
	{
		cout << "=copy" << endl;
		return *this;
	}
	~hasY() = delete;
};

	hasY hy;
	hasY hy2 = hy;
	hasY hy3;
	hy3 = hy;

int i(0); // 舊版初始化
int i{0};或int i ={0}; // C++11列表初始化
int i = 0; // 這是賦值初始化,，是初始化
int j; j = i; // 這個才是賦值,，而拷貝操作函數(shù)也有相同性質(zhì)。
class hasY
{
public:
	hasY() = default;

	hasY(const hasY&)
	{
		cout << "copy" << endl;
	}

	hasY& operator=(const hasY&)
	{
		cout << "=copy" << endl;
		return *this;
	}
};

	1,、hasY hy; //調(diào)用合成構(gòu)造函數(shù)
	2,、hasY hy2 = hy; // 輸出copy，編譯器跳過=號,，相當(dāng)于hasY hy2(hy)
	3,、hasY hy3; // 調(diào)用合成構(gòu)造函數(shù)
	4、hy3 = hy; // 輸出=copy

class A
{
public:
     A(){cout << "construct" << endl;}      //1
     A(const A&){cout << "copy" << endl;}   //2
     A(const A&&) {cout << "move" << endl;}  //3
};

void main()
{
    A a;
    A b(a);
    A c(std::move(b));
}

      紅框里的輸出結(jié)果就是了。這里應(yīng)該很清晰了,，當(dāng)我們利用std::move把類b轉(zhuǎn)成一個右值時,，就調(diào)用了移動構(gòu)造函數(shù)。前面我們的例子太簡單了,，一般的移動構(gòu)造函數(shù)至少要遵守這樣的原由：必須讓被竊取的對象與原來的資源切斷聯(lián)系,這里特別要注意指針,。

class A
{
public:
     // 這里不能用const,因?yàn)橄旅嬉膕ource內(nèi)的值
     A(const A&& source) noexcept:a(source.a),b(source.b) 
     {
        source.a = source.b = nullptr;
     }

public:
    int *a;
    char *b; 
};

上面的移動構(gòu)造函數(shù)的實(shí)質(zhì)是怎么樣的呢？

 

 從圖中可以看出,，移動構(gòu)造函數(shù)實(shí)質(zhì)就是“竅取”資源,，它本身不分配任何資源，所以也沒有調(diào)用到相應(yīng)的構(gòu)造函數(shù),。上圖這種情況,，當(dāng)我們“竅取”了b的資源后，所以b的資源的歸屬權(quán)已經(jīng)變更了,，根據(jù)移動函數(shù)的約定：當(dāng)移動后的源應(yīng)該是銷毀無害的,，但如果我們不處理的話，當(dāng)我們b生命周期結(jié)束,，肯定會影響到對象c的,。

事實(shí)上，移動構(gòu)造函數(shù)是解決指針,，特別是臨時指針在復(fù)制時,，如果數(shù)據(jù)量消耗效率的問題。比如上面的函數(shù)，如果我們是一個內(nèi)置類型,，結(jié)果會如何呢,？：

class A{
public:
     // 因?yàn)橛辛艘苿訕?gòu)造函數(shù)，不會再合成默認(rèn)構(gòu)造函數(shù)了
     A():a(0),b(new char('a')){}
     A(A& source):a(source.a)
     {
       // 不像移動構(gòu)造函數(shù),，拷貝構(gòu)造函數(shù)一般都是另外分配內(nèi)存空間后再進(jìn)行賦值
        b = new char(*(source.b));
     }
     // 這里不能用const,因?yàn)橄旅嬉膕ource內(nèi)的值
     A(A&& source) noexcept:a(source.a),b(source.b) 
     {
        source.b = nullptr;
     }

public:
    int a; 
    char *b;
};
void main()
{
    A a;
    cout << (void*)a.b << endl;
    A b(std::move(a));
    cout << &(a.a) << " " &(b.a) <<  endl;
    cout << (void*)a.b << " " << (void*)b.b << endl;
    cout << &(a.b) << " " << &(b.b) << endl;
}

    如果你前面讓我誤導(dǎo)了（我承認(rèn)我那圖很爛,，我們我只寫了堆和棧，但并不詳盡,，反正堆一般是new分配的）,，認(rèn)為移動函數(shù)是一種機(jī)制，那輸出的結(jié)果就讓你哭了,。

    說到底,，移動函數(shù)也是符合C++語義的，如果你什么都不做,，它也是什么都不處理,。上面的輸出結(jié)果中,，a和b是兩個類,，有各自的內(nèi)存空間，所以輸出內(nèi)置型的數(shù)據(jù)時(它在棧上，包括b這個指針本身,，也是在棧上),，它因?yàn)槭莾蓚€對象分別控制的,，所以第二行輸出的地址不同；第三行就比較有意思,，它輸出的是移動后的源和當(dāng)前變量的指針地址,，它們是相同的，為什么第一個是空指針呢,？因?yàn)槲覀冊谝苿雍?，把移后源設(shè)置為nullptr，但我在第一行cout輸出了未清空的地址,。第四行,，它也是輸出棧上的指針變量，所以它的地址也是不同的,。
     考慮一下,，只是為了解決指針的復(fù)制問題，我們?nèi)匀豢梢岳每截悩?gòu)造函數(shù)執(zhí)行跟移動構(gòu)造函數(shù)一樣的操作（代碼一樣時）,，但這樣雖然有移動構(gòu)造函數(shù)的功能,，但它有兩個問題（假設(shè)舊版本沒有std::move情況下）：
1、它無法將一個臨時變量快速處理（即無法支持右值引用）
2,、假設(shè)我們對拷貝構(gòu)造函數(shù)這樣做了,，那很明顯，當(dāng)我們需要對象連堆都一起分離出來該怎么辦呢,？所以說,，這種情況下，我們這樣做是不現(xiàn)實(shí)的,。事實(shí)上它也一般定義為const,。C++引進(jìn)移動構(gòu)造函數(shù)后,，就魚和熊掌都可兼得了。
    最后,，我們注意到那個noexcept,，這也是C++11新引進(jìn)的。它位于參數(shù)列表和puvcwx列表開始的冒號之間,。它指示程序不拋出任何異常,，其實(shí)可以想像，我們只是“竅取”數(shù)據(jù),，并沒有進(jìn)行任何移動類的操作,，所以根本不會發(fā)生什么錯誤。標(biāo)準(zhǔn)庫中的vector類中的pushback也有這種東西,，失敗時并不會彈出一個異常,。

class A{
public:
     // 因?yàn)橛辛艘苿訕?gòu)造函數(shù),，不會再合成默認(rèn)構(gòu)造函數(shù)了
     A():a(0),b(new char('a')){}
     A(A& source):a(source.a)
     {
       // 不像移動構(gòu)造函數(shù),，拷貝構(gòu)造函數(shù)一般都是另外分配內(nèi)存空間后再進(jìn)行賦值
        b = new char(*(source.b));
     }
     // 這里不能用const,因?yàn)橄旅嬉膕ource內(nèi)的值
     A(A&& source) noexcept:a(source.a),b(source.b) 
     {
        source.b = nullptr;
     }
     A& operator=(A&& source) noexcept
     {
          if(this != &source) // 比較地址,，不能自身進(jìn)行賦值構(gòu)造
          {
             // 清空數(shù)據(jù)
             free();
             this->a = source.a;
             this->b = source.b;
             // 記得處理好移動后源的數(shù)據(jù),，指針的一定要清空,，保證它銷毀是無害的 
             source.b = nullptr;
          }
         return *this;
     }

public:
    int a; 
    char *b;
};

struct hasY
{
  hasY() = default;
  hasY(hasY&&) = default; // 因?yàn)閅,，它是=delete的
  //假設(shè)這里的類Y定義有自己的拷貝構(gòu)造函數(shù)（不會再合成移動操作函數(shù)），
    卻也沒有定義自己的移動操作法函數(shù)
    Y mem;
};
hasY hy,hy2 = std::move(hy); // 錯誤,，沒有移動構(gòu)造法函數(shù),，它是刪除的

class A
{
 public:
    A() = default;
    A(const A&) // 定義了拷貝構(gòu)造函數(shù)后,，編譯器不會再合成任何的移動構(gòu)造函數(shù)
    {
        cout << "copy" << endl,；
    }
};
A x;
A y(x); // 拷貝構(gòu)造函數(shù)，x為一個左值,，它能取地址,，有名稱的
A z(std::move(x)); 
//盡管std::move后的類型為A&&類型，但沒有移動操作函數(shù)時,，仍然是調(diào)用拷貝構(gòu)造函數(shù),，而且是肯定安
  全的。這時會進(jìn)行隱匿的類型轉(zhuǎn)換,，把一個右值引用A&&轉(zhuǎn)換為一個const A&引用,，即使我們拷貝構(gòu)造函數(shù)
  定義為A(&),它仍然能接受一個A&&的右值類型。
*前面說右值引用時提過的const變量應(yīng)該記得吧,？任務(wù)一個引用都要求右邊的值是左值,，但如果是const引
 用，則右邊的值可以是一個右值,，因?yàn)閏onst要求一個常量值,，而常量值都是一個右值。構(gòu)造函數(shù)形參可以
是非const而安全接受右值,，其實(shí)原理也相當(dāng)簡單：對于構(gòu)造函數(shù)來說,，主要責(zé)任是構(gòu)造一個新對象，即便修改
了右值,，也無所謂,，反正臨時的東西，扔了就行了,。但是普通函數(shù),，目的不是為了別的，就是為了處理傳進(jìn)來
的值,，傳進(jìn)來的引用,，是既能in又能out的。所以這里如果非const引用一個右值,，那肯定會讓out的結(jié)果失效。
所以對于普通函數(shù)而言，要想接受一個右值必須是一個const類型的形參,；沒有所謂的機(jī)制,，只是編譯器是這
樣定義的。
void hit(const int &) //假如沒有const說明右邊可以是右值,，則std::move后的值不能用于參數(shù)
{
	cout << "function" << endl; 
}
int iv = 4;
hit(std::move(iv)); // 正確

      有個提醒,，我不建議在除了類定義外的移動操作函數(shù)。因?yàn)樗浅２环€(wěn)定,，你不能確定移后源對象的確切狀態(tài),，是否仍然有其它的對象在使用它。我們說過,，移后源應(yīng)該是可以隨時釋放清空而不影響其它操作的,，而且，我們不能對其內(nèi)數(shù)據(jù)進(jìn)行操作,。但誰又能100%知道當(dāng)前移后源的狀態(tài)呢,，特別是大項(xiàng)目中，這個更是致命,。

    看到了嗎？我們的const版本函數(shù),，就算跟普通成員名稱,，返回值和參數(shù)完全一致，但它仍然是一個重載版本,。而對于以const作為形參的函數(shù),。卻不是重載函數(shù)，因?yàn)镃++規(guī)定,，頂層const作為形參時,，是會被忽略const標(biāo)識的,。
    還有一種情況。

string s1,s2;
s1 + s2 = "test";

    上面這段代碼,，s1+s2后是由s1返回一個臨時變量（即右值）,，但我們卻對右值進(jìn)行了重新賦值。當(dāng)然,，在語法上是沒有問題,，但使用上卻幾乎無法重獲這個"test"字符串，除非我們std::move()了它,。這種用法是很普遍的,，但我們卻很想禁止這種用法。以前不行,，C++11為我們準(zhǔn)備了新的工具,。
    好了，現(xiàn)在我們說下新引進(jìn)的“引用函數(shù)”吧,。
1,、語法
      我們通過在移動操作函數(shù)或拷貝操作函數(shù)后增加引用限定符，就可以阻某些用法,。
      引用限定符（只能用于非static）有兩種,，分別是"&"和"&&"，前者表示this（類對象本身）只可以指向一個左值,，而后者表示this只可以指向一個右值,。

class Foo
{
public:
	Foo &operator= (const Foo&) &;
};
Foo& Foo::operator=(const Foo& )&
{
	return *this;
}

  這個類的賦值運(yùn)算符只允許左側(cè)的操作數(shù)即類對象本身是一個左值。如果我們這樣操作：
   Foo f,i;
   std::move(f) = i;
   這是無法成立的,。

2,、重載和引用函數(shù)
    C++11中新增加的這種引用函數(shù)，跟const成員函數(shù)一樣,，可通過引用限定符來區(qū)分重載版本,。
    前面已經(jīng)看到，我們定義const成員函數(shù)時,，可以定義兩個版本,，唯一罰沒是一個有const限定，一個沒有,。而對于有引用限定符的成員函數(shù),，有一點(diǎn)不一樣：*如果我們定義兩個（兩個是重載的最低要求，不然還叫什么重載）或兩個以上具有相同名字和相同參數(shù)列表的成員函數(shù)（C++中,，返回值不作為重載的考量依據(jù)）時,，就必須對所有重載的幾個函數(shù)都加上引用限定符，讓它變?yōu)橐孟薅愋偷暮瘮?shù),，或者所有不加作為普通成員函數(shù)定義,。

class Foo
{
public:
	Foo storted() && ;
	// 錯誤：要么把前面的變?yōu)槠胀ǔ蓡T函數(shù),，要么在const后面也加上&&（記得，是&&不是&,，引用限定符是分兩種的）
	Foo sorted() const; 
	Foo sorted(Comp*);
	Foo sorted(Comp*) const;
};

*注意點(diǎn)：
1）當(dāng)一個成員函數(shù)帶有引用限定符,，那么無論是聲明還是定義,，它都必須要帶上,。
2）引用限定符必須寫在函數(shù)的最后位置，如果是const成員函數(shù),，就寫在const后面,。