C++ 知识点总结
平時在學習C++的時候一些零碎的知識點將會記錄在此處
目錄
- 1、CLOCKS_PER_SEC、
- 2、C++的右值引用
- 3、模板函數
- 5、定位new運算符
- 6、靜態變量的表示方法
- 7、類的static常量
- 8、新枚舉的定義
- 9、轉換函數
- 10、類的靜態成員
- 11、C++ 類的常量的初始化
- 12、類的繼承，關于類的虛析構函數的調用
- 13、類的upcast以及downcast，向上隱式類型轉換，向下強制類型轉換
- 14、 派生類方法為什么可以使用作用域解析運算符來調用共有和受保護的基類方法
- 15、私有繼承測試，可使用強制類型轉換來顯示對象
- 16、模板的具體化
- 17、成員模板
- 17.1 在類里面聲明并且定義模板類
- 17.2 在類外面聲明并且定義模板類
- 18、模板類的非約束模板友元函數
- 19、模板別名
- 20、public 繼承 與 protect，private 繼承的區別
- 21、嵌套類
- 22、noexcept 關鍵字
- 23、類的友元問題
- 24、getline() 函數
- 25、智能指針
- 26、標準模板庫
- 27、現有的標準模板庫
- 27.1、序列式容器
- 27.2、關聯式容器
- 27.3、無序關聯容器
- 27.4、STL 和 string 類
- 28、泛型編程
- 29、函數對象
- 30、STL 的算法的通用性
- 31、functional 頭文件中的類對象，相當于運算符
- 32、STL 的使用，一個實用的例子
- 33、關于STL的其他庫
- 33.1 關于 slice 類的使用情況
- 33.2 關于 initializer_list 類的使用情況
- 34、獲取物理內存
- 35、copy() 函數的使用
- 36、C++文件I\O
- 36.1、輸入輸出文件 - 追加文件
- 36.2、輸入輸出文件 - 二進制文件
- 36.3 C++ 隨機讀寫文件(二進制)
- 37、使用臨時文件
- 38、C++內核格式化
- 39、探討C++11新標準
-1、std::initializer_list 模板類
-2、decltype 關鍵字
-3、返回類型后置
-4、作用域內枚舉
-5、引入 explicit 關鍵字
-6、C++11允許在類內初始化成員
-7、基于范圍的 for 循環
-8、STL 的移動構造函數
-9、STL 的移動賦值運算符
-10、右值引用
-11、移動語義
-12、強制移動
-15、使用 delete 或者 default 來聲明
-16、委托構造函數
-17、管理虛方法的 override 和 final
-18、Lambda 表達式
-19、包裝器
-20、可變參數的模板
-21、C++11新增的其他功能
—21.1、并行編程
—21.2 新增的庫
------21.2.1、random 頭文件
------21.2.2、chrono 頭文件
------21.2.3、tuple 頭文件
------21.2.4、ratio 頭文件
------21.2.5、在新增的庫中，最有趣的一個是頭文件 regex 支持的正則表達式庫
—21.3 低級編程
—21.4 雜項
—21.5、語言變化
-22、C++內存對齊
1、CLOCKS_PER_SEC
延時，可能并不是每一臺電腦的 一秒 就是 1000ms直接在代碼里面使用1000這種方法并沒有很好的移植性 因為每一個系統的clock()函數調用之后返回的類型不一定是 long 有的也有可能是 unsignedlong 所以為了解決這一個問題，ctime 頭文件引入了一個CLOCKS_PER_SEC 宏，該宏值代表著當前系統每一秒包含的系統時間單位數。
2、C++的右值引用
左值和右值的區分標準在于能否獲取地址，最早的c++中，左值的定義表示的是可以獲取地址的表達式，它能出現在賦值語句的左邊，對該表達式進行賦值。但是修飾符const的出現使得可以聲明如下的標識符，它可以取得地址，但是沒辦法對其進行賦值；右值表示無法獲取地址的對象，有常量值、函數返回值、Lambda表達式等。無法獲取地址，但不表示其不可改變，當定義了右值的右值引用時就可以更改右值。
3、模板函數
函數模板是函數的通用函數描述，也就是說，他們使用泛型來定義函數，其中的泛型可以使用具體的類型來代替，比如 int double
通用格式
template
void Swap(AnyType& a,AnyType& b)
{
AnyType temp;
temp = a;
a = b;
b = temp;
}
注意：typename 有時候使用 class 關鍵字會出錯，所以一般建議使用關鍵字 typename
decltype(a + b) 是以 a + b 表達式的類型來推斷變量類型
4、注意
在同一個項目文件下，不同的.cpp文件不能同時定義兩個相同的變量 如：兩個全局變量
5、定位new運算符
通俗來說就是借別人的地兒來乘涼，在棧區找一塊非托管內存來做事情，定位new運算符出來的對象時將已經分配的內存視作他用，所以不能delete，pd4 = new (buff)double[N];中buff是一個靜態字符串地址，所以buff在這里的作用是提供定位內存的起始地址
6、靜態變量的表示方法
1、static int counts;
2、namespace
{
int count;
}
上述兩種方法均可以表示靜態變量 即沒有名稱的名字空間相當于靜態變量
7、類的static常量
靜態變量不屬于類，更不屬于所有類的實例，所以另外類的靜態變量必須要在類的外部再重新定義一次不然會出現 無法解析的外部符號 “public: static int A::a” (?a@A@@2HA) 的錯誤
8、新枚舉的定義
9、轉換函數
class A{ private:double num; public:A(double num) {this->num = num;}operator double()const; };A::operator double()const{return num; } int main(){A a(5.00);//double b = a; 要是沒有類的轉換函數，報錯無法轉換類型double b = a;//所以類的轉換函數只能用于當類類型需要轉換成標準數據類型的時候自動調用該函數std::cout << b << std::endl;return 0; }10、類的靜態成員
class A{ public:static const int m = 5;//static int n = 6;//發生錯誤，不能在類內初始化靜態變量 }; int main(){/*A a;std::cout << a.m << std::endl;*/A a;printf("%p\n", &A::m);printf("%p\n", &a.m);//打印的兩個地址完全一樣，說明類靜態成員不屬于對象//類的靜態成員不屬于類return 0; }11、C++ 類的常量的初始化
參數初始化列表可用于初始化類類型的常量，其他方式則不行
12、類的繼承，關于類的虛析構函數的調用
1、派生類首先構造基類，再構造派生類，就是說派生類對象創建時，先為基類分配內存空間
2、基類指針或者引用可以指向派生類對象
3、基類析構函數不是虛函數時，基類指針將不會調用派生類析構函數
4、基類析構函數是虛函數時，基類指針將會調用派生類析構函數
5、最好習慣于給類定義一個虛析構函數，即使這個虛析構函數不做任何工作
6、類不定義虛析構函數(如果不使用該類當作基類)，則程序執行的效率更高
7、如果類是設計當作基類的話，如果構造函數沒有動態分配內存的話，也可以不使用虛析構函數，分配了內存就一定要使用虛析構函數，便于在對象釋放的時候可以清除內存，防止內存泄漏
13、類的upcast以及downcast，向上隱式類型轉換，向下強制類型轉換
14、 派生類方法為什么可以使用作用域解析運算符來調用共有和受保護的基類方法
class A{ public:virtual void show() {std::cout << "aaaa Hello World" << std::endl;} };class B : public A{ public:void bbb();void show() {std::cout << "bbbb Hello World" << std::endl;} };void B::bbb(){show();A::show();//需要作用域解析運算符的原因是表明調用的函數是屬于誰的 }int main(){B b;b.bbb();return 0; }15、私有繼承測試，可使用強制類型轉換來顯示對象
#include <iostream> #include <string> using std::string; class Student : string{ public://使用 using 指令將 基類的成員函數變成派生類的公有訪問權限函數/*-------單獨指明那個函數可以使用------*/using string::size;//沒有這條之前，是無法使用size函數的，加上這一條就可以使用size函數了char tel[15]{ 0 };Student(const char* name, const char* telphone) : string(name){std::strcpy(tel, telphone);} };int main(){Student stu("NULL NAME", "15879668139");std::cout << stu.tel << std::endl;std::cout << (const string&)stu << std::endl;//使用強制類型轉換，把對象顯示出來，這就//是私有繼承的一大特點，也是需要顯示匿名類對象的一種方法std::cout << stu.size() << std::endl;return 0; }16、模板的具體化
/* * 1、隱式實力化 * 2、顯式實例化 * 3、顯式具體化 * 4、部分具體化 */// 1、編譯器在需要對象之前，不會生成類的隱式實例化： // Array<double, 30>* pt; 只是一個指針，沒有對象存在 // pt = new Array<double, 30>;生成對象 // 第二條語句導致編譯器生成類定義，并根據該定義創建一個對象// 2、當使用關鍵字 template 并指出所需類型來聲明類時，編譯器將生成類的顯示實例化，就是聲明 // 模板類在程序中的一中特定的類型<必須在模板定義的名稱空間中>，就相當于生成一個具體的類// 3、4、就是有時候特定的類型可能定義的方法不實用，需要特定處理，就出來一個顯式具體化，書寫方式 // template <1> class Classname <2> // {} // 說明:第一個尖括號，是模板在聲明時不指定特殊類型的參數，第二個則是需要設定的參數，要特殊指定的 // 才在第二個尖括號里面，不需要的在第一個尖括號里面，(這種情況是部分顯式具體化)，例如 // template <typename T> class Classname <const char*>{} 這就是部分具體化/* * 如果有多個模板可以選擇，編譯器首先選擇具體化程度最高的模板，別問為什么，要是你你也會這樣 */17、成員模板
17.1 在類里面聲明并且定義模板類
17.2 在類外面聲明并且定義模板類
template <typename T> class beta{ private:template <typename V>class hold;hold<T> q;hold<int> n; public:beta(T t, int i) : q(t), n(i) {}template<typename U>U blab(U u, T t);void show() const {q.show(); n.show();} };//類外面的模板類定義 template <typename T> template <typename V> class beta<T>::hold{ private:V val; public:hold(V v = 0) : val(v) {}void show() const {cout << val << endl;}V Value() const {return val;} };//模板類的方法定義 因為有兩個模板參數 固需要兩次模板聲明 template <typename T> template <typename U> U beta<T>::blab(U u, T t){return (n.Value() + q.Value()) * u / t; }18、模板類的非約束模板友元函數
template <typename T> class ManyFriend{ private:T item; public:ManyFriend(const T& i) : item(i) { }template <typename C, typename D>friend void show1(C& c, D& d); //非約束模板友元函數 }; template<typename C, typename D> void show1(C& c, D& d){//NotImplementedException沒有實際的異常//throw gcnew System::NotImplementedException();cout << c.item << ", " << d.item << endl; }int main(){ManyFriend<int> hfi1(10);ManyFriend<int> hfi2(20);ManyFriend<double> hfdb(10.5);cout << "hfi1,hfi2: ";show1(hfi1, hfi2);cout << "hfdb,hfi2: ";show1(hfdb, hfi2);return 0; }19、模板別名
#include <array> using std::array; template <typename T> //模板頭部 using arrType = array<T, 12>; //將arrType作為模板的別名 arrType<double> gallons;//C++11允許將語法 using = 用于非模板，當用于非模板時，這種語法與常規的 typedef 等價20、public 繼承 與 protect，private 繼承的區別
class base{ public:base() : iBase(0) {}virtual ~base() {} private:int iBase; };class A : public base{ public:A() {} private:int iA; };class B : protected base{ public:B() {} private:int iB; };class C : private base{ public:C() {} private:int iC; };int main(){base* a = new A();//base* b = new B(); 由于這兩個類當中，基類是屬于在外部不可訪問的，所以這兩句存在語法錯誤//base* c = new C();return 0; }21、嵌套類
class Queue{ public:Queue();class in_queue{public:int a;}; };Queue::Queue(){in_queue inq;//inq.a -----> 嵌套類當中，如果嵌套的類當中的成員變量是私有的，在外部類是訪問不了的 }22、noexcept 關鍵字
關鍵字 noexcept 修飾的函數表示告訴編譯器該函數不會引發異常行為
23、類的友元問題
24、getline() 函數
getline(cin, str, ‘;’); //第三個參數指定輸入邊界，不包括那個字符
25、智能指針
26、標準模板庫
1、STL.erase(STL.begin(), STL.begin() + 2);//刪除 vector 的第一和第二個元素
27、現有的標準模板庫
27.1、序列式容器
27.2、關聯式容器
//1、set :<鍵與值的類型相同>關聯集合，可反轉，可排序，且鍵是唯一的，不能存儲多個相同的值，對于 set 來說，值就是鍵 //2、multiset :和 set 類似，就是可能有多個值的鍵是相同的，即一個鍵對應多個值 //3、map :<鍵與值的類型不同>，鍵是唯一的，每個鍵只對應一個值，根據 key 值自動默認按升序排序 //4、multimap :與 map 相似，只是一個鍵可以對應多個值27.3、無序關聯容器
無序關聯容器的介紹：和關聯容器相比，關聯容器底層使用樹來實現數據結構，而無序關聯容器則使用哈希表，以便能夠快速存取數據，旨在提高添加和刪除元素的速度以及提高查找算法的效率
27.4、STL 和 string 類
//1、string 類算然不是 STL 的組成成分，但是設計它時考慮到了 STL，例如它包含了 begin(),end(),rbegin(),rend()等成員 //2、排列組合就是重新安排容器中元素的順序，next_permutation() 算法將區間內容轉換成下一種排序方式，對于字符串，按照字母遞增的順序進行，如果成功返回 true，如果區間已經在最后的序列中，則返回 false //3、string str("I love C++"); // next_permutation(str.begin(), str.end()); //結果變為: I love+ +C28、泛型編程
面向對象編程關注的是編程的數據方面，而泛型編程關注的是算法，他們的共同特點是抽象和創建可重用的代碼，但是理念絕然不同
迭代器是遍歷容器的通用表示，適合于各種數據類型，才使得方法的通用性
STL 實際上按功能的強弱定義了多種級別的迭代器
實際上，作為一種編程風格，應該盡量避免直接使用迭代器，盡可能的使用 STL 函數(for_each())來處理細節，也可以使用C++11的 范圍for循環
29、函數對象
binder1st 和 binder2nd類以及bind1s()t和bind2nd()函數
#include <functional> #include <algorithm> #include <iostream> #include <vector> #include <string> std::plus<int> add;//二元函數對象 void showvec(int n){std::cout << n << " "; } bool comp(int n){return n < 10; } int main(){using namespace std;string str("I love C++");next_permutation(str.begin(), str.end()); //結果變為: I love+ +Cint a = add(9, 11); //利用對象將兩個數相加less<int> mul;vector<int> vec(5, 15);for_each(vec.begin(), vec.end(), showvec);cout << endl;//bind1st()函數是將目標值作為第一個參數，如 bind1st(less<int>(), 10) 的意思是 10 < val//bind2nd()函數是將目標值作為第二個參數，如 bind2nd(less<int>(), 10) 的意思是 val < 10//couny_if()函數功能:返回容器當中符合條件的個數int b = count_if(vec.begin(), vec.end(), binder2nd<less<int>>(less<int>(), 10));//bind1st()函數可以簡化一下count_if()函數的參數int c = count_if(vec.begin(), vec.end(), bind2nd(less<int>(), 10));//然而C++11提供了代替這種寫法的 lamda 表達式int e = count_if(vec.begin(), vec.end(), [](int x)->bool { return x < 10; });//采用外部函數對象形式int d = count_if(vec.begin(), vec.end(), comp);for_each(vec.begin(), vec.end(), showvec);cout << endl;return 0; }30、STL 的算法的通用性
//1、對算法進行分類的方式之一就是按結果放置的位置進行分類 //2、有些算法就地完成工作，有一些創建拷貝。 //3、sort()函數完成時，結果被存放在原始數據的位置上，一次，sort() 是就地算法(in-place algorithm) //4、copy()函數將結果發送到另一個位置，所以他是復制算法(copying algorithm) //5、有的算法有兩個版本:就地版本和復制版本，STL 的約定是，復制版本的名稱將以 _copy 結尾，復制版本將額外的接受一個輸出迭代器的參數，即結果放置的位置 //6、另一個常見的變體是:有些函數有這樣的版本，即根據將函數應用于容器當中得到的結果來執行操作，這些版本的名稱通常以 _if 結尾，例如 count_if() 函數，remove_if() 函數31、functional 頭文件中的類對象，相當于運算符
//add 就相當于一個對象 + 運算符了，functional 頭文件中還有許多類似的運算符，當然，這些類都在名字空間 std 當中 //+ plus //- minus //* multiplies /// divides //% modulus //- negate(相反數，負號) //== equal_to //!= not_equal_to //> greater //< less //>= greater_equal //<= less_equal //&& logic_and //|| logic_or //! login_not32、STL 的使用，一個實用的例子
#include <string> #include <vector> #include <set> #include <map> #include <iterator> #include <algorithm> #include <cctype> using namespace std;char toLower(char ch) {return tolower(ch); } string& ToLower(string& st); void display(const string& s) {cout << s << " "; }int main(){vector<string> words;cout << "Enter words (enter quit to quit):" << endl;string input;while (cin >> input && input != "quit")words.push_back(input);cout << "You entered the following words:" << endl;for_each(words.begin(), words.end(), display);cout << endl;//place words in set, converting to lowercaseset<string> wordset;transform(words.begin(), words.end(), insert_iterator<set<string>>(wordset, wordset.begin()), ToLower);cout << "\nAlphabetic list of words:" << endl;for_each(wordset.begin(), wordset.end(), display);cout << endl;//place word and frequency in mapmap<string, int> wordmap;set<string>::iterator si;for (si = wordset.begin(); si != wordset.end(); ++si)wordmap[*si] = count(words.begin(), words.end(), *si);//display map contentscout << "\nWord frequency:" << endl;for (si = wordset.begin(); si != wordset.end(); ++si)cout << *si << ": " << wordmap[*si] << endl;return 0; }string& ToLower(string& st){transform(st.begin(), st.end(), st.begin(), toLower);//在 st 開始到結束區間內，每一個字符都轉換為小寫，并從 st 的開始位置覆蓋return st; }33、關于STL的其他庫
33.1 關于 slice 類的使用情況
33.2 關于 initializer_list 類的使用情況
//使用 initializer_list //要在代碼中使用 initializer_list 對象，必須包含頭文件 initializer_list。這個模版類包含成員函數 begin(),end(),您可以 //使用這些函數來訪問列表元素，它還包含了成員函數 size(),該函數返回元素數，下面是一個簡單的程序使用了 initializer_list //她要求編譯器支持 C++11 新增的 initializer_list //initializer_list 的迭代器類型是 const 類型，因此您不能通過迭代器來修改她的值 //然而，開發 initializer_list 類的初衷就是為了讓您能夠使用一系列值傳遞給構造函數或者其他函數#include <iostream> #include <initializer_list>double sum(std::initializer_list<double> il); double average(const std::initializer_list<double>& ril);int main() {using std::cout;cout << "List 1: sum = " << sum({ 2,3,4 }) << ", ave = " << average({ 2,3,4 }) << '\n';std::initializer_list<double> dl = { 1.1,2.2,3.3,4.4,5.5 };cout << "List 2: sum = " << sum(dl) << ", ave = " << average(dl) << '\n';dl = { 16.0,25.0,36.0,40.0,64.0 };cout << "List 3: sum = " << sum(dl) << ", ave = " << average(dl) << '\n';return 0; } double sum(std::initializer_list<double> il) {double tot = 0;for (auto p = il.begin(); p != il.end(); ++p)tot += *p;return tot; }double average(const std::initializer_list<double>& ril) {double tot = 0;int n = ril.size();double ave = 0.0;if (n > 0){for (auto p = ril.begin(); p != ril.end(); ++p)tot += *p;ave = tot / n;}return ave; }34、獲取物理內存
#include <stdio.h> #include <Windows.h>void main() {int availmb;int totalmb;MEMORYSTATUS memstatus;GlobalMemoryStatus(&memstatus);availmb = memstatus.dwAvailPhys / 1024 / 1024; //可用物理內存總量totalmb = memstatus.dwTotalPhys / 1024 / 1024; //物理內存總量printf("可用內存為:%d MB，物理內存總量:%d MB\n", availmb, totalmb); }35、copy() 函數的使用
copy(ar, ar + sizeof(ar) / sizeof(ar[0]), ostream_iterator(cout, " "));//將數組內容拷貝到 輸出流當中使用ostream_iterator迭代器，讓指針輸出到 ostream 流
36、C++文件I\O
36.1、輸入輸出文件 - 追加文件
36.2、輸入輸出文件 - 二進制文件
#include <iostream> #include <fstream> #include <iomanip> #include <cstdlib> //for exit()inline void eatline() {while (std::cin.get() != '\n') continue; } struct plant {char name[20]; //name of plantetdouble population; //its populationdouble g; //its acceleration of gravity };const char* file = "planets.dat";int main() {using namespace std;plant p1;cout << fixed << right;//show initial contentsifstream fin;fin.open(file, ios::in | ios::binary);//Note:some system don't accept the ios::binary modeif (fin.is_open()){cout << "Here are the current contents of the " << file << " file" << endl;while (fin.read((char*)& p1, sizeof p1)){cout << setw(20) << p1.name << ": "<< setprecision(0) << setw(12) << p1.population<< setprecision(2) << setw(6) << p1.g << endl;}fin.close();}//add new namesofstream fout(file, ios::out | ios::app | ios::binary);if (!fout.is_open()){cout << "Can't open " << file << " file for outpupt" << endl;exit(EXIT_FAILURE);}cout << "Enter guest names (enter a blank line to quit):" << endl;cin.get(p1.name, 20);while (p1.name[0] != '\0'){eatline();cout << "Enter plantetary population:";cin >> p1.population;cout << "Enter plant's acceleration of gravity: ";cin >> p1.g;eatline();fout.write((char*)& p1, sizeof p1);cout << "Enter plant name (enter a blank line to quit):" << endl;cin.get(p1.name, 20);}fout.close();//show revised filefin.clear(); //not necessary foe some compilersfin.open(file, ios::in | ios::binary);if (fin.is_open()){cout << "Here are the new contents of the " << file << " file:" << endl;while (fin.read((char*)& p1, sizeof p1)){cout << setw(20) << p1.name << ": "<< setprecision(0) << setw(12) << p1.population<< setprecision(2) << setw(6) << p1.g << endl;}fin.close();}cout << "Done" << endl;return 0; }36.3 C++ 隨機讀寫文件(二進制)
#include <iostream> #include <fstream> #include <iomanip> #include <cstdlib> const int LIM = 20; struct planet {char name[LIM]; //name of plantetdouble population; //its populationdouble g; //its acceleration of gravity }; const char* file = "planets.dat"; inline void eatline() {while (std::cin.get() != '\n') continue; } int main() {using namespace std;planet p1;cout << fixed;//show initial contentsfstream finout;finout.open(file, ios::in | ios::out | ios::binary);//Note:some system don't accept the ios::binary modeint ct = 0;if (finout.is_open()){finout.seekg(0);cout << "Here are the current contents of the " << file << " file" << endl;while (finout.read((char*)& p1, sizeof p1)){cout << ct++ << setw(LIM) << p1.name << ": "<< setprecision(0) << setw(12) << p1.population<< setprecision(2) << setw(6) << p1.g << endl;}if (finout.eof())finout.clear(); //clear eof flagelse{cerr << "Error in reading " << file << endl;exit(EXIT_FAILURE);}}else{cerr << file << "could not be opened -- bye" << endl;exit(EXIT_FAILURE);}//change a recordcout << "Enter the record number you wish to change:";long rec;cin >> rec;eatline();if (rec < 0 || rec >= ct){cerr << file << "Invalid record number -- bye" << endl;exit(EXIT_FAILURE);}streampos place = rec * sizeof p1;finout.seekg(place);if (finout.fail()){cerr << file << "Error on attempted seek" << endl;exit(EXIT_FAILURE);}finout.read((char*)& p1, sizeof p1);cout << "Your selection:" << endl;cout << rec << ": " << setw(LIM) << p1.name << ": "<< setprecision(0) << setw(12) << p1.population<< setprecision(2) << setw(6) << p1.g << endl;if (finout.eof())finout.clear();cout << "Enter planet name:";cin.get(p1.name, LIM);eatline();cout << "Enter planet's acceleration of gravity:";cin >> p1.g;finout.seekp(place);//go backfinout.write((char*)& p1, sizeof p1) << flush;if (finout.fail()){cerr << file << "Error on attempted write" << endl;exit(EXIT_FAILURE);}//show revised filect = 0;finout.seekg(0);//go to beginning of filecout << "Here are the new contents of the " << file << " file:" << endl;while (finout.read((char*)& p1, sizeof p1)){cout << ct++ << setw(LIM) << p1.name << ": "<< setprecision(0) << setw(12) << p1.population<< setprecision(2) << setw(6) << p1.g << endl;}finout.close();cout << "Done" << endl;return 0; }37、使用臨時文件
#include <cstdio> //包含生成臨時文件名字的函數 tmpnam() #include <iostream> int main() {using namespace std;cout << "This system can generate uo to " << TMP_MAX << " temporary names of up to " << L_tmpnam << " characters" << endl;char pszname[L_tmpnam] = { '\0' };cout << "Here are ten names:" << endl;for (int i = 0; i < 10; ++i){tmpnam(pszname);cout << pszname << endl;}return 0; }/* * 更具體的說，使用tmpnam()可以生成TMP_NAM個不同的文件名，其中每一個文件名包含的字符不錯過L_tmpnam個，生成什么樣的文 * 件名取決于實現 */38、C++內核格式化
#include <iostream> #include <sstream> #include <string> using namespace std; int main() {string facts = "10 10 10 10";istringstream instr(facts);int n = 0, sum = 0;while (instr >> n) //可以直接匹配字符串中的數字，將其相加sum += n;cout << sum << endl;return 0; }/* * 可以使用于 cout 的 ostream 方法將格式化信息寫入到 string 對象當中，并使用 istream 方法(如 getline() )來讀取 * string 對象中的信息，這種讀取 string 對象的格式化信息或將格式化信息寫入string對象中被稱為內核格式 * 使用str()成員函數可以“凍結”該對象，這樣便不能將信息寫入該對象 */39、探討C++11新標準
1、std::initializer_list 模板類，可以將其用作構造函數的參數，列表當中的元素必須是同類型的或者可以轉換成同類型
2、decltype 關鍵字，關鍵字聲明的類型是表達式指定的類型， decltype(x) y;含義是讓y與x的類型相同，x是一個表達式，這個關鍵字在平時比較少用，但是在模板當中很常見，比如要返回的類型是需要根據模板具體化來的，T V 為模板參數，decltype(T V),還有一種常見的用處在C++11的返回類型后置的時候用得到
3、返回類型后置，auto fun(int,double) -> double;而對于模板來說，如下:
template <typename T,typename U)
auto eff(T t,U u) -> decltype(TU){ … }
在這里解決的問題是，在編譯器遇到 eff 參數列表的前，T 和 U 都不在作用域范圍內，因此必須在參數列表后面使用 decltype
4、作用域內枚舉，之前枚舉之間是不能有同名元素的，但是新語法可以，但是在定義枚舉的時候需要顯示的寫上枚舉名稱
enum old { yes,no,maybe }
enum new1 { never,sometimes,often,always }
enum new2 { never,leve,sever } 這樣便可以使用同名稱，但是在使用的時候必須加上作用域限定符，如new1::never，等等
5、引入 explicit 關鍵字，以禁止單參數構造函數導致的自動轉換
6、C++11允許在類內初始化成員，減少構造函數的工作以及減少編寫程序時出錯的機會
7、基于范圍的 for 循環，專門為 STL 容器和 數組設定的，可以簡化編寫代碼的工作
8、STL 的移動構造函數: 雖然使用右值引用可支持移動語義，但是這并不會神奇的發生；有時候我們會遇到這樣一種情況，我們用對象a初始化對象b，后對象a我們就不在使用了，但是對象a的空間還在呀（在析構之前），既然拷貝構造函數，實際上就是把a對象的內容復制一份到b中，那么為什么我們不能直接使用a的空間呢？這樣就避免了新的空間的分配，大大降低了構造的成本。這就是移動構造函數設計的初衷。基本步驟就是：傳入同類對象，將this對象的指針指向該同類對象分配的空間，而不進行深拷貝操作，并且將該同類對象的指向該空間的指針置為 nullptr，移動構造的參數必須為右值引用，在實參為臨時對象時調用該函數
9、STL 的移動賦值運算符: 同是也是減少不必要的操作，大大降低了構造的成本，移動賦值運算符的基本步驟：刪除this對象分配的空間，讓該指針指向賦值符號右邊對象所分配的空間，并且讓右邊對象指針置為 nullptr，移動賦值的參數必須為右值引用
10、右值引用 傳統的C++引用(現在稱為左值引用)，使得標識符關聯到左值，左值是一個數據的表達式(如變量名或者解除引用的指針)，程序可以獲得其地址
C++11新增的右值引用，這是使用 && 表示的，右值引用可以關聯到右值，即可以出現在賦值表達式的右邊，但是不能對其使用地址運算符，右值包括字面常量(c - 風格字符串除外，他表示地址)，諸如 x + y等表達式以及返回值的函數(條件是該函數返回的不是引用)，通俗的來說就是右值指向的是一個臨時對象，可以讓右值來接收他，右值引用的意義通常解釋為兩大作用：移動語義和完美轉發
11、移動語義，實際的文件內容還留在了原來的地方，只是將記錄集給改了，這種方法稱為移動語義，這其實實際上避免了移動原始數據，而只是修改了記錄要實現移動語義，需要采取某種方式，讓編譯器知道什么時候需要復制，什么時候不需要，這就是右值引用發揮作用的地方。
12、強制移動，假設在10個當中選擇最佳的一個，我們循環選擇一遍之后賦值給一個新的該類型變量，而原來的數據還在其中，但我們希望的是新變量保存改數據，原來的數據將從當中刪除，要是有像移動構造或者移動賦值這樣的函數就好了，為此C++11標準在 utility 頭文件當中包含了一個擁有這樣功能的函數 std::move() ，既可以實現上述功能，這樣稱為強制移動，當然也可以使用運算符 static_cast<> 將對象的類型強制轉換成 類的右值引用類型，再使用移動賦值運算符，但是明顯上述C++11的方式更為簡單粗暴
13、對于大多數程序員來說，右值引用帶來的主要好處并非是讓他們能夠編寫使用右值引用的代碼，而是能夠使用利用右值引用實現移動語義的庫代碼，例如，STL 類現在都有復制構造函數，移動構造函數，復制賦值運算符和移動賦值運算符
14、在C++11當中，新的類已經在原有的4個特殊成員函數的基礎上，增加了移動構造和移動賦值運算符，這些成員函數是各種編譯器在各種情況下自動提供的
15、使用 delete 或者 default 來聲明已刪除函數和采取默認提供的函數要比 把函數放在私有部分或者再重新編寫一遍要好的多
16、委托構造函數，肯能兩個構造函數只有一個參數的差別，其他參數相同，這就意味著肯能你要編寫大量重復的代碼，這時候委托構造函數就起到作用了，可以在初始化列表當中調用之前一個構造函數，簡化代碼，這樣的就稱之為委托構造函數
17、管理虛方法的 override 和 final，其中 override 是為了在派生類當中要是覆蓋了錯誤的虛函數(即參數錯了或者參數個輸錯了，一般沒有override關鍵字將不提示錯誤)版本會產生編譯錯誤，final 則是為了禁止派生類覆蓋特定的方法，當然，override 和 final 并不是C++11的關鍵字，在其他地方可以用作變量名或者枚舉，他只在特定的地方根據上下文有效
18、Lambda 表達式，語法形式:[] () -> ReturnType { … } 當且僅當函數體重有返回值的時候需要使用返回類型后置，當然他也可以自動推斷(主體只由一條返回語句組成)，無返回語句的時候，默認返回類型為 void，()小括號內的為參數，[]中括號內可有講究了，如果只指定了變量名，則按值訪問，如果使用 &變量名 則按引用訪問，[&]可以按引用訪問所有動態變量，而[=]將可以按值訪問所有動態變量，還可以混合使用[a,&b]可以按值訪問a，按引用訪問b，[&,c]可以按引用訪問除c之外的所有動態變量，[=,&d]以此類推
19、包裝器，C++提供了多個包裝器(wrapper，也叫做適配器[adapter])，這些對象用于給其他編程接口提供更一致或更合適的接口通俗地講，就是提供一種指定的類型，讓一些使用函數指針，函數對象，Lambda表達式并且調用特征標相同(特征標就是有返回類型以及用括號括起并用逗號分隔的參數類型列表定義的)，所以這些調用特征標相同的上述三個對象就可以使用包裝器包起來，相當于包裝成一模一樣，這樣在模板實例化的時候就只會實例化一次，從而降低了內存的使用
20、可變參數的模板，使用可變參數的模板，必須考慮4個要點:模板參數包，函數參數包，展開參數包以及遞歸，使用包的定義的話模板頭和函數頭可以這樣寫:template<typename… Args> 以及 void show_list(Args… args)，來表示，如果直接遞歸調用show_list(srgs…)的話會導致一個嚴重問題，無限遞歸，改進方法就是使用兩個模板參數，第一個表示具體類型，第二個表示模板參數包，這樣在參數包為空的時候可以退出遞歸，代碼如下:
21、C++11新增的其他功能
21.1、并行編程
現代計算機都配備了多核心處理器的裝備，這為計算機高效的處理數據提供了物理基礎，這讓計算機可以同時執行多個線程，在同一時間內，處理不同的事情，但是這雖然是一個好東西，好用，但是管理起來會比較繁瑣，若同一個變量可以同時被多個線程所訪問并且都有權利修改這個變量，這將會發生錯亂，所以必須有東西來管理線程，C++定義了一個支持線程化執行的內存模型添加了關鍵字 thread_local，提供了相關的庫支持，關鍵字 thread_local 將變量聲明為靜態存儲，其持續性于線程相關，即線程過期時，變量也將過期，其中，庫支持由原子操作(atomic opertion)庫和線程支持庫組成，其中原子操作庫提供了頭文件atomic，而線程支持庫提供了頭文件thread，mutex，condition_variable 和 future
21.2 新增的庫
21.2.1、random 頭文件
支持的可擴展隨機數庫提供了大量比rand()復雜的隨機數工具，例如，您可以選擇隨機數生成器和分布狀態，分布狀態包括均勻分布(類似于rang())、二項式分布和正態分布
21.2.2、chrono 頭文件
提供了處理時間間隔的途徑
21.2.3、tuple 頭文件
支持模板tuple，tuple是一個廣義的pair對象，pair對象可存儲兩個類型不同的值，而tuple對象可以存儲任意多個類型不同的值
21.2.4、ratio 頭文件，支持的編譯階段有理數算數庫讓您能夠表示任何有理數，其分子和分母可用最寬的整形表示，它還支持對這些有理數的算術運算
21.2.5、在新增的庫中，最有趣的一個是頭文件 regex 支持的正則表達式庫，正則表達式指定了一種模式，可用于與文本文字符串的內容匹配，例如，方括號表達式與方括號中的任何單個字符匹配，因此[cCkK]與c，C，k，K都匹配，而[cCkK]at與單詞cat，Cat，kat，Kat都匹配，其他模式包括與一維數組匹配的\d,與一個單詞匹配的\w,與制表符匹配的\t等，在C++中，斜杠具有特殊含義，因此對于模式\d\t\w\d(即依次為一個數字，制表符，單詞和一位數字)，必須寫成字符字面量"\d\t\w\d"，即使用 \表示\，這是引入原始字符串的原因之一，讓您能夠將該模式寫成R"\d\t\w\d"，ed，grep和awk等UNIX工具都是用正則表達式，而解釋型語言Perl擴展了正則表達式的功能，C++正則表達式庫讓您能夠選擇多種形式的正則表達式
21.3 低級編程
所謂的"低級"指的是抽象程度，而不是編程質量，低級意味著接近于計算機硬件和機器語言使用比特和字節，對嵌入式編程和改善操作的效率而言，低級編程很重要，變化之一是放松了POD(Plain Old Data)的要求，在C++98，POD是一種標量類型，是可安全地逐字節復制的東西，C++11認識到了這一點，也保留了原有的理念，這有助于低級編程，因為有些低級操作要求處理對象為 POD另一項修改是允許共用體的成員有構造函數和析構函數，這讓共用體更加靈活C++11解決了內存對齊的問題，要獲悉有關類型或者對象的對齊要求，可以使用運算符 alignof()，要控制對齊方式，可以使用說明符alignasconstexpr 機制讓編譯器能夠在編譯階段計算結果為常量的表達式，讓const變量可存在只讀內存中，這對嵌入式編程很有用
21.4 雜項
C++11新增了調試工具 assert，這是一個宏，它在運行階段對斷言進行檢查，如果為true，則顯示一條消息，否則調用 abort()，C++11新增了關鍵字 static_assert，可用于在編譯階段對斷言進行測試，這樣做的主要目的在于，對于在編譯階段(而不是運行階段)實例化的模板，調試起來更簡單，C++11加強了對元編程(metaprogramming)的支持，元編程是指編寫這樣的程序，他創建或者修改其他程序，甚至自身，在C++中，可使用模板在編譯階段完成這項工作
21.5、語言變化
Boost項目，TR1，后者是一個庫的擴展選集，這些擴展，這些擴展與C++98標準兼容，但不是必不可少的，這些擴展是下一個C++標準的候選內容，在 TR1 中，Boost庫占了很大一部分
22、C++內存對齊
總結
- 上一篇： gcnew 与 new 的区别
- 下一篇： 总结Linux-ubuntu基本配置方法