C++ Primer筆記

C++ Primer筆記

目錄

• ch2 變量和基本類型
• ch3 字符串、向量和數組
• ch4 表達式
• ch5 語句
• ch6 函數
• ch7 類
• ch8 IO庫
• ch9 順序容器
• ch10 泛型算法
• ch11 關聯容器
• ch12 動態內存
• ch13 拷貝控制
• ch14 重載運算與類型轉換
• ch15 面向對象程序設計
• ch16 模板與泛型編程

ch2 變量和基本類型

聲明

extern int i;
extern int i = 3.14;//定義

左值引用（綁定零一變量初始值，別名）

不能定義引用的引用；引用必須被初始化；類型嚴格匹配；不能綁定字面值/計算結果；沒法二次綁定

int i=4;
int &r=i;

指針

自己是對象，容許賦值和拷貝；無需定義時賦初值；類型嚴格匹配

int *ip1, *ip2;
int ival = 42;
int *p = &ival;
*p = 0;
cout << *p;
int *p2 = p;
int &r2 = *p;

指針值：1.指向一個對象；2.指向緊令對象的下一個位置；3.nullptr；4.無效指針

不能把int變量直接賦值給指針

有時候沒法清楚賦值語句改變了指針的值仍是指針所指對象的值：賦值永遠改變等號左邊的對象

指針比較：（==）相等時意味着地址值相等（都爲空/指向同一對象/指向同一對象的下一地址）

**表示指向指針的指針

int ival = 1024;
int *pi = &ival;
int **ppi = π//ppi指向pi的地址
int *pi2 = pi; //pi2和pi指向同一對象

指向指針的引用

int i = 42;
int *p;
int *&r = p;//r是p的引用

r = &i;//r引用了p，此處讓p指向i
*r = 0;

理解r的類型是什麼，最簡單的是從右向左讀r的定義，&r的&代表r是一個引用，*說明r引用的是一個指針，int指出r引用的是一個int指針

const

必須初始化；

默認狀態下，const對象僅在文件內有效，共享必須添加extern

//文件間共享const對象
extern const int bufSize = fcn();//定義初始化常量，且能被其餘文件訪問
extern const int bufSize;

const引用

初始化常量引用時容許用任意表達式

int i = 42;
const int &r1=i;
const int &r2=42;
const int &r3=r1*2;

double dval = 3.14;
const int &ri = dval;//浮點數生成臨時常量再綁定

對const的引用可能會引用一個並不是const的對象

指向常量的指針：不能經過該指針改變對象的值。

double dval = 3.14;
const double *cptr = &dval;

const指針(必須初始化，值不能改變)

//從右向左肯定含義
int errNumb = 0;
int *const curErr = &errNumb;//curErr一直指向errNumb
const double pi = 3.14;
const double *const pip = π//pip是一個指向常量對象的常量指針

• 頂層const：指針自己是常量
• 底層const：指針所指對象是常量

int i = 0;
    int *const pi = &i;//頂層const
    const int ci = 42;//頂層const
    const int *p2 = &ci;//底層const
    const int *const p3 = p2;//靠右是頂層，靠左是底層
    const int &r = ci;//用於聲明的都是底層const
    //拷貝時，頂層const不受影響；底層const必須相同
    i = ci;
    p2 = p3;
    int *p = p3;//wrong,p3有底層，p沒有
    p2 = p3;//都是底層
    p2 = &i;//int*能轉換爲const int*
    int &r = ci;//wrong，int&不能綁定到int常量上
    const int &r2 = i;//const int&能夠綁定到int

常量表達式：constexpr

ch3 字符串、向量和數組

頭文件不該包含using聲明

string

1. 定義和初始化

   string s1 = "hiya";//默認初始化使用=
   string s2("hiya");//直接初始化
   string s3(10,'c');//直接初始化

2. getline(cin, line),使用endl結束當前行並刷新緩衝區

3. empty和size操做
   size返回值：string::size_type。返回的是一個無符號整數，不要使用int了

4. 比較（長度/大小寫敏感）

5. 賦值/對象相加/字面值與string相加（保證每一個加法運算對象之一是string）

6. 處理字符：range for語句

   decltype(s.size()) punct_cnt = 0;//使用s.size()返回值類型聲明punct_cnt
   for(auto &c : s){...}//加引用改變字符

7. 下標（隨機訪問）

vector（容器/類模板）

1. 定義和初始化

   vector<T> v1//默認初始化
   vector<T> v2(v1);
   vector<T> v2 = v1;
   vector<T> v4(n);//值初始化
   vector<T> v5{a,b,c,...};//列表初始化
   vector<T> v6={a,b,c,...};

2. 操做

   v.push_back()//添加
   v.empty()
   v.size()//vector<int>::size_type
   v1 = v2;//拷貝
   v1 = {a,b,c}//列表拷貝
   v1 == v2;//數量相同且元素值相同

   不能用下標添加元素

迭代器

*iter//返回iter所指元素的引用
iter->data//解引用獲取data的成員，等價於(*iter).data
++iter
--iter
iter1 == iter2
auto e = v.end();//由於end返回的迭代器不指示某個元素，不能對其遞增或解引用的操做

迭代器運算

數組

//初始化
const unsigned sz = 3;
int a[] = {0,1,2};
int a[5] = {0,1,2};
string a[] = {"hi","bye"}
int a2[]=a;//wrong,不容許拷貝賦值
a2 = a;
int *ptrs[10];//ptrs含有10個整形指針
int &refs[10];//wrong
int (*Parray)[10] = &arr;//Parray指向一個含有10個整數的數組
int (&arrRef)[10] = arr;arrRef引用一個含喲10個整數的數組
//數組的名稱由內向外讀
int * (&array)[10] = ptrs://array是數組的引用，該數組包含10個指針

訪問數組元素(size_t,無符號)

指針和數組

string nums[] = {"one", "two", "three"};
string *p = nums;//等價於p2 = &nums[0]
auto ia(nums);//ia是一個string指針，指向nums的第一個元素

指針也是迭代器

int ia[] = {0,1,2};
int *beg = begin(ia);
int *last = end(ia);

尾後指針不能解引用和遞增操做

C風格字符串

strlen(p)
strcmp(p1, p2)
strcat(p1, p2)//p2附加到p1以後
strcpy(p1, p2)//p2拷貝給p1

混用string和C風格字符串

char *str = s;//wrong
const char *str = s.c_str();

使用數組初始化vector對象

int int_arr[] = {0,1,2,3,4,5};
vector<int> ivec(begin(int_arr), end(int_arr));
vector<int> subVec(int_arr+1, int_arr+4);
//儘可能使用vector和迭代器；儘可能使用string

多維數組

int ia[2][3] = {
    {1,2,3},
    {2,3,4}
};
//下標引用
ia[2][3] = arr[0][0][0];
int (&row)[4] = ia[1];//row綁定到ia的第二個4元素數組上
size_t cnt = 0;
for(auto &row : ia)//不加引用則沒法編譯
	for(auto &col : row){
    	col = cnt++;
}
//指針和多維數組
int ia[3][4];
int (*p)[4] = ia;
p = &ia[2];//p指向ia的尾元素

ch4 表達式

重載運算符（運算對象的類型和返回值的類型）

• （對象被用做）左值：用的是對象的身份（內存地址）
  1. 賦值運算符運算左值對象，返回左值
  2. 取地址符做用於左值，返回指向該運算的指針（右值）
  3. 解引用/下標/迭代器/string和vector的下標運算符，結果爲左值
  4. 內置類型和迭代器的遞增遞減運算符，做用於左值，返回左值
• （對象被用做）右值：用的是對象的值（內容）

處理複合表達式

• 拿不許的時候最好用括號來限制
• 若是改變了某個運算對象的值，在表達式的其餘地方不要再使用這個運算對象（*++iter例外）

溢出和其餘算術運算符異常（「環繞」）

//（-m)/n和m/(-n)等於-(m/n)，m%(-n)等於m%n,（-m)%n等於-(m%n)
//除法運算中，兩個運算對象的符號相同則商爲正，不然爲負
//取餘運算中，m和n是整數且n非0，則(m/n)*n+m%n的結果與m相同
-21 % -8 = -5	-21 / -8 = 2
21 % -5 = 1	 21 / -5 = -4

進行比較運算時除非比較的對象是布爾類型，不然不要使用true和false做爲運算對象。

賦值運算知足右結合律

除非必須，不然不使用遞增遞減運算符的後置版本（相對複雜的迭代器類型，額外工做消耗巨大）

一條語句中混用解引用和遞增運算符（*iter++|後置遞增運算符返回初始的未加1的值）

while(beg != s.end() && !isspace(*beg))
	*beg = toupper(*beg++);//wrong
*beg = toupper(*beg);
*(beg+1) = toupper(*beg);

條件運算符（？）右結合律，優先級比<<低

sizeof(所得的值是size_t類型)

//sizeof運算可以返回整個數組的大小
constexpr size_t sz = sizeof(ia)/sizeof(*ia);
int arr[sz];

類型轉換

• 隱式轉換
  1. 比int小的整數型首先提高爲較大的整數類型（算術轉換/數組->指針/指針轉換）
  2. 條件中，非布爾轉換爲布爾
  3. 初始化過程當中，初始值轉換成變量類型；賦值語句中，右側運算對象轉換成左側類型
  4. 算術運算/關係運算的運算對象多種類型，須要轉換成同一種類型
  5. 函數調用時
• 顯示轉換

  • static_cast：最普遍，除了底層const

  • const_cast：之惡能改變運算對象的底層const，常量對象轉換爲很是量對象

    const char *pc;
    char *p = const_cast<char*>(pc);
    char *q = static_cast<char*>(pc);//wrong
    static_cast<string>(pc);
    const_cast<string>(pc);//wrong

  • reinterpret_cast：爲運算對象的位模式提供較低層次上的從新解釋。

  • dynamic_cast：支持運算時類型識別
    儘可能避免強制類型轉換

ch5 語句

懸垂else：else就近匹配

switch語句內部的變量定義

case true:
	string file_name;//wrong，隱式初始化
	int ival = 0;//wrong，顯式初始化
	int jval;//true
	break;
case false:
	jval = next_num();
	if(file_name.empty()){}

範圍for：不能經過範圍for增長vector對象元素，由於預存end()，一旦再序列中添加/刪除元素，end函數的值就可能變得無效了。

跳轉語句

• break：做用範圍僅限於最近循環/switch
• continue：中斷迭代，繼續執行循環
• goto：無條件跳轉到同一函數內的另外一條語句
  不要在程序中使用goto，會使得程序難理解難修改

try-catch語句塊

• throw表達式

  Sales_item item1, item2;
  cin >> item1 >> item2;
  if(item1.isbn()!=item2.isbn())
  	throw runtime_error("Data must refer to same ISBN!");
  //拋出runtime_error異常，用string對象初始化
  cout << item1+item2<<endl;

• try-catch()

  while(cin >> item1 >> item2){
      try{
          //
      }catch (runtime_error err){
   		cout << err.what() << endl;       
      }
  }

  函數在尋找處理代碼的過程當中退出：編寫異常安全代碼十分困難

• 標準異常

  • exception:定義最通用的異常類，報告異常的發生
  • stdexcept:定義幾種常見的異常類
  • new定義bad_alloc異常類型
  • type_info定義bad_cast異常類型

ch6 函數

函數：返回類型，函數名字，0個或多個形參組成的列表，函數體

局部對象

• 名字的做用域是程序文本的一部分，名字在其中可見；
• 對象的生命週期是程序執行過程當中該對象存在的一段時間。
• static局部靜態對象，第一次通過對象定義語句後初始化，直到程序結束才終止

變量和函數在頭文件中聲明(不包含函數體)，在源文件中定義

分離式編譯：多文件組成的程序是如何編譯並執行的

參數傳遞

• 傳值參數（不影響初始值）

  //指針形參，執行指針拷貝時，拷貝的時指針的值；拷貝後，兩個指針不一樣指向同一對象
  void reset(int *ip)
  {
      *ip = 0;//改變指針ip所指對象的值
      ip = 0;//改變ip的局部拷貝，實參未被改變
  }
  int i = 0;
  reset(&i);
  //建議使用引用類型的形參替代指針

• 傳引用

  void reset(int &i){ i = 0; }
  int j = 42;
  reset(j);
  //使用引用避免拷貝，若無須修改引用形參的值，聲明爲常量引用

  const形參和實參

  const int ci = 42;//wrong,const頂層
  int i = ci;//實參初始化形參和拷貝時，忽略頂層const
  int *const p = &i;//wrong,const頂層
  *p = 0;
  void fcn(const int i)//不能向i寫值
  void fcn(int i)//wrong,重複定義

  指針/引用形參與const

  int i = 42;
  const int *cp = &i;//cp don't change i
  const int &r = i;//r don't change i
  const int &r2 = 42;
  int *p = cp;//wrong,type don't match
  int &r3 = r;//wrong,type don't match
  int &r4 = 42;//wrong,字面值不能初始化很是量引用
  
  const int ci = i;
  string::size_type ctr = 0;
  reset(&i);
  reset(&ci);//wrong,不能用指向const int對象指針初始化int*
  reset(i);
  reset(ci);//wrong，普通引用不能綁定在const對象上
  reset(42);//wrong,普通引用不能綁定在字面值
  rest(ctr);//wrong，type don't match
  find_char("hello world!", 'o', ctr);

  儘可能使用常量引用
  數組形參

  print(const int*)
  print(const int[])
  print(const int[10])
  int i = 0, j[2]={0,1};
  print(&i);
  print(j);//j轉換爲int*指向j[0]

  管理指針形參三種經常使用的技術

  • 標記指定數組長度

    void print(const char *cp){
        if(cp)
        	while(*cp) cout << *cp++ << endl;
    }

  • 標準庫規範

    void print(const int *beg, const int *end)
    {
        while(beg != end) cout << *beg++ << endl;
    }

  • 顯示傳遞數組大小形參

    void print(const int ia[], size_t size)
    {
        for(size_t i = 0; i < size; ++i) cout << ia[i] << endl;
    }

  數組引用形參

  void print(int (&arr)[10]){}
  f(int &arrp[10])//wrong,將arr聲明成了引用的數組
  f(int (&arr)[10])//true,arr是包含10個整數的數組引用
  
  void print(int (*matrix)[10], int rowSize){}
  void print(int matrix[][10], int rowSize){}//二者等價

  含有可變形參的函數：initializer_list形參（用於與C函數交互的接口）

  void error_msg(initializer_list<string> il)
  {
      for(auto beg = il.begin();beg!=il.end();++beg)
      	cout << *beg << endl;
  }

return 語句：不要返回局部對象的引用或指針

• 引用返回左值

  char &get_val(string &str, string::size_type ix) return str[ix];
  int main()
  {
      string s("a value");
      get_val(s,0) = 'A';
      cout << s << endl;
  }

• 列表初始化返回值

• 返回數組指針

  //聲明一個返回數組指針的函數
  int arr[10];//10個整數的數組
  int *p1[10];//10個整數指針
  int (*p2)[10] = &arr;//p2指向arr
  
  int (*func(int i))[10];//func的調用進行解引用後獲得一個10的數組
  //尾置返回類型
  auto func(int i)->int (*)[10];
  //使用decltype
  decltype(odd) *arrPtr(int i)
  {
      return (i % 2) ? &odd : &even;
  }

  函數重載(函數名字相同形參列表不一樣)

  • 重載和const形參：頂層const不影響傳入函數的對象，一個擁有頂層const的形參沒法與一個沒有頂層const的形參區分開來

  • 最好是重載那些確實很是類似的操做

  • const_cast和重載

    string &shorterString(string &s1, string &s2)
    {
        auto &r = shorterString(const_cast<const string&>(s1),
        					  const_cast<const string&>(s2));
        return const_cast<string&>(r);
    }

  特殊用途語言特性

  • 默認實參

    typedef string::size_type sz;
    string screen(sz ht = 24, sz wid = 80, char backgrnd = ' ');
    //一般，應該在頭文件函數聲明中指定默認實參

  • 內聯函數和constexpr函數(定義在頭文件中)

    //避免函數調用的開銷，在編譯時展開
    //能用於常量表達式的函數
    constexpr size_t scale(size_t cnt) { return new_sz() * cnt; }
    int arr[scale(2)];
    int i =2;
    int a2[scale(i)];//wrong，scale(i)不是常量表達

  • 調試幫助

    • assert預處理宏assert(word.size() > threshold)

    • NDEBUG預處理變量

      void print(const int ia[], size_t size)
      {
         #ifndef NDEBUG
         	cerr << __func__<< "" << endl;
         #endif
      }
      __FILE__存放文件名
      __LINE__存放當前行號
      __TIME__存放文件編譯時間
      __DATE__存放文件編譯日期

  函數匹配
  函數指針：指向是函數而非對象。函數的類型由返回類型和形參類型共同決定

  bool lengthCompare(const string &, const string &);
  bool (*pf)(const string &, const string &);//not initialize
  pf = lengthCompare;
  bool b1 = pf("hello world", "goodbye");
  bool b2 = (*pf)("hello world", "goodbye");//equal
  bool b3 = lengthCompare("hello world", "goodbye");//equal
  //重載函數的指針
  void ff(int*);
  void ff(unsigned int);
  void (*pf1)(unsigned int) = ff;
  //函數指針形參
  void useBigger(const string &s1, const string &s2,
  				bool pf(const string&, const string&));
  useBigger(s1, s2, lengthCompare);
  //函數
  typedef bool Func(const string&, const string&);
  typedef decltype(lengthCompare) Func2;//equal
  //指向函數的指針
  typedef bool (*FuncP)(const string&, const string&);
  typedef decltype(lengthComapre) *FuncP;//equal
  //返回指向函數的指針
  //auto和decltype用於函數指針

  聲明getFcn惟一須要注意的地方是，牢記當咱們將decltype做用於某個函數時，它返回函數類型而非指針類型。顯示加上*代表須要返回指針，而非函數自己.

ch7 類

定義在類內部的函數時隱式的inline函數

成員函數經過一個名爲this常量指針的額外的隱式參數來訪問調用它的那個對象。

const放在成員函數參數表後，代表this時一個指向常量的指針。

//定義read和print函數
istream &read(istream &is, Sailes_data &item)
{
    double price = 0;
    is >> item.bookNo >> item.units_sold >> price;
    item.revenue = price * item.units_sold;
    return is;
}
osteam &print(ostream &os, const Sales_data &item)
{
    os << item.isbn() << " " << item.units_sold << " " << item.revenue << " " << item.avg_price() << endl;
    return os;
}

構造函數

1. 默認構造函數：無需任何實參
2. 構造函數初始值列表
3. 拷貝/賦值/析構

訪問控制和封裝（public|private;class|struct)

• 確保用戶代碼不會無心間破壞封裝對象的狀態。
• 被封裝的類的具體實現細節能夠隨時改變，而無需調整用戶級別的代碼

友元函數(friend函數聲明|類定義開始/結束位置集中聲明友元)

重載成員函數

可變數據成員：mutable

//返回*this的成員函數
inline Screen &set(char);//若返回類型不是引用，則返回值時*this的副本
myScreen.display(cout).set('*');//wrong，display返回常量引用*this，沒法set一個常量對象
//基於const的重載
Screen &display(std::ostream &os){return *this;}
const Screen &display(std::ostream &os) const {return *this;}
myScreen.set('&').display(cout);//調用很是量版本
blank.display(cout);//常量版本

建議：對於公共代碼使用私有功能屬性

類之間的友元關係：friend聲明，友元類的成員函數能夠訪問此類非公有成員

建議：使用構造函數初始值

委託構造函數

class Sales_data{
    public:
    	Sales_data(std::string s, unsigned cnt, double price):
    			bookNo(s), units_sold(cnt), revenue(cnt*price){}
    	//委託delegate
    	Sales_data():Sales_data("",0,0){}
    	Sales_data(std::string s):Sales_data(s, 0, 0){}
    	Sales_data(std::istream &is): Sales_data(){ read(is, *this);}
};

隱式類類型轉換：經過將構造函數聲明爲explicit加以阻止，只能用於直接初始化，且對一個實參的構造函數有效

類的靜態成員（static關鍵字）：存在於任何對象以外，成員函數不包含this指針

double r = Account::rate();
Account ac1;
Account *ac2 = &ac1;
r = ac1.rate();
r = ac2>rate();//經過對象/指針訪問

靜態成員的類內初始化，使用constexpr,但一般狀況下依然在類外定義該成員。

ch8 IO庫

IO類

• iostream定義了用於讀寫流的基本類型
• fstream定義了讀寫命名文件的類型
• sstream定義了讀寫內存string對象的類型

標準庫能使咱們忽略不一樣類型的流之間的差別：繼承機制實現的

IO對象無拷貝或賦值：不能將形參或返回類型設置爲流類型，一般以引用方式傳遞返回流，不能使const的

緩衝刷新的緣由：

1. 程序正常結束，main函數的return操做的一部分，緩衝刷新被執行
2. 緩衝區滿時，刷新
3. 使用endl顯示刷新
4. 每一個書除操做以後，用unitbuf設置流的內部狀態，清空緩衝區。默認狀況下，cerr時設置unitbuf的
5. 輸出流關聯到另外一個流時。如cin和cerr都關聯到cout，讀寫cin和cerr會致使cout的緩衝區被刷新

使用flush和ends刷新緩衝區(輸出一個空字符)

警告：若是程序崩潰，書除緩衝區不會被刷新

文件輸入輸出

ifstream in(ifile);
ofstream out;
out.open(ifile+".copy");
in.close();
in.open(ifile+"2");

當一個fstream對象被銷燬時，close會自動被調用，自動構造和析構

在每次打開文件時，都要設置文件模式，可能時顯示地設置，也多是隱式地設置。當程序未指定模式，使用默認值。

string流：某些工做對整行文本進行處理，而其餘工做是處理行內地某個單詞，用istringstream

string line, word;
vector<PersonInfo> people;
while(getline(cin,line)){
    PersonInfo info;
    istringstream record(line);
    record >> info.name;
    while(record >> word)
    	info.phones.push_back(word);
    people.push_back(info);
}

ostringstream:逐步構造輸出，最後一塊兒打印

ch9 順序容器

• vector:可變大小數組，支持快速隨機訪問，在尾部以外地位置插入或刪除可能很慢
• deque：雙端隊列，支持快速隨機訪問，在頭尾位置插入/刪除速度很快
• list：雙向鏈表，只支持雙向順序訪問，list任何位置插入/刪除速度很快
• forward_list：單向鏈表，只支持單項順序訪問，鏈表任何位置進行插入/刪除速度很快
• array：固定數組大小，支持快速隨機訪問，不能添加/刪除元素
• string：與vector類似地容器，專門保存字符，隨機訪問很快，尾部插入/刪除快

選擇哪一種順序容器

• 一般選擇vector
• 程序中有不少小的元素，且空間額外開銷很重要，不要使用list和forward_list
• 程序要求隨機訪問元素，使用vector和deque
• 要求中間插入/刪除元素，使用list和forward_list
• 要求頭尾插入/刪除元素，中間不插入/刪除，使用deque
• 只在讀取輸入時在中間插入元素，則
• • 首先，肯定是否真的須要在容器中間插入元素，藉助vector和sort
  • 必須中間插入元素，輸入階段使用list，結束後拷貝到vector

容器操做：P330

迭代器範圍由一對迭代器表示，begin和end，[begin,end)，帶r的版本返回反向迭代器，以c爲開頭的版本返回const迭代器

容器定義和初始化

C c;//默認構造函數
C c1(c2);//拷貝
C c1 = c2;
C c{a,b,c}；//列表初始化
C c={a,b,c};
C c(b,e)//c初始化爲b和e指定範圍內元素的拷貝。
C seq(n)；//seq包含n個元素，構造函數時explicit的
C seq(n,t);//seq包含n個初始值爲t的元素

容器賦值運算

c1 = c2;//c1替換爲c2的拷貝
c = {a,b,c};//c1元素替換爲c2的拷貝
swap(c1,c2);
c1.swap(c2);//swap比從c2到c1拷貝快得多
seq.assign(b,e)//seq元素替換爲b,e表示範圍內的元素
seq.assign(il)
seq.assign(n,t)
//assign能夠將char*值賦予list
list<string> name;
vector<const char*> oldstyle;
names = oldstyle;//wrong，類型不匹配
names.assign(oldstylee.cbegin(),oldstyle.cend());

關鍵概念：容器元素時拷貝

push_front:list，forward_list,deque支持，常數級

vector,deque,list,string支持insert,比較耗時

slist.insert(iter, "Hello!");
svec.insert(svec.end(),10,"Anna");
slist.insert(slist.begin(),v.end()-2,v.end());
slist.insert(slist.end(),{"these","words"});
slist.insert(slist.begin(),slist.begin(),slist.end());//wrong，迭代器表示拷貝範圍，不能指向與目的位置相同的容器
iter = lst.insert(iter,word);//等同於push_front()

emplace_front_{push_front,emplace}insert,emplace_back~push_back,用於容器中直接構造元素

at和下標操做只適用於string、vector、deque、array

back不適用於forward_list

若是容器爲空，front和back時未定義的

c.pop_back()//刪除c中尾元素，c爲空，行爲未定義，返回void
c.pop_front()//刪除c中首元素，c爲空，行爲未定義，返回void
c.erase(p)
c.erase(b,e)//返回一個指向最後一個被刪元素以後元素的迭代器，若e爲尾後迭代器，返回尾後迭代器
c.clear()
//刪除deque除首尾以外的任何元素都會使任何迭代器、指針、引用失效

forward_list特殊版本的添加/刪除操做

vector是如何增加的

• size：容器已經保存的元素數量
• capacity：不分配新的內存空間最多能夠保存多少元素

不一樣的分配策略遵循一個原則：確保用push_back添加元素的操做由高效率

額外的string操做

string s(cp,n)//cp指向的數組前n個字符
string s(s2,pos2)//s2從pos2開始的字符的拷貝
string s(s2,pos2,len2)//s2從pos2開始len2字符的拷貝
string s2 = s.substr(0,5)
string s2 = s.substr(6)
s.append(args);//args追加到s，返回s的引用
s.replace(range,args);//將range字符替換成args
//搜索操做
string name("AnnaBelle");
auto pos1=name.find("Anna");
string numbers("0123456789"),name("r2d2");
auto pos = name.find_first_of(numbers);
string dept("03714p3");
auto pos = dept.find_first_not_of(numbers);
//compare函數

數值轉換

int i = 42;
string s = to_string(i);
double d = stod(s);

容器適配器：stack,queue,priority_queue

本質上，一個適配器是一種機制。每一個適配器都在其底層順序接口容器上定義了一個新的接口。

ch10 泛型算法

算法：實現了一些經典算法的公共接口

泛型：它們能夠用於不一樣類型的元素和多種容器類型（包括標準庫vector和list以及內置的數組類型）

算法遍歷由兩個迭代器指定的一個元素範圍進行操做

迭代器令算法不依賴於容器，但算法依賴於元素類型的操做

關鍵：算法不會執行容器的操做，只會運行於迭代器之上，算法永遠不會改變底層容器的大小

• 只讀算法

  find
  //求和
  int sum = accumulate(vec.cbegin(), vec.cend(), 0);
  string sum = accumulate(v.cbegin(), v.cend(), string(""));//去掉string會致使編譯錯誤，不能直接傳遞字面值
  //比較兩個序列
  equal(roster1.cbegin(), roster1.cend(), roster2.cbegin());//假定第二個序列至少與第一個序列同樣長

• 寫容器元素算法

  fill(vec.begin(), vec.end(), 0);//每一個元素重置爲0，寫操做安全
  //算法不檢查寫操做
  fill_n(vec.begin(), vec.size(), 0);
  vector<intj> vec;
  fill_n(vec.begin(), 10, 0);//結果未定義wrong

  迭代器參數：兩個序列的元素能夠來自不一樣的容器。
  插入迭代器：back_inserter

  vector<int> vec;
  fill_n(back_inserter(vec), 10, 0);

  copy算法

  int a1[] = {0,1,2,3,4};
  int a2[sizeof(a1)/sizeof(*a1)];
  auto ret = copy(begin(a1), end(a1), a2);
  replace(ilst.begin(), ilst.end(), 0, 42);
  replace_copy(ilst.cbegin(), ilst.cend(), back_inserter(ivec), 0 ,42);//ivec包含ilst的一份拷貝

• 重排容器元素算法

  void elimDupe(vector<string> &words){
      sort(words.begin(), words.end());
      auto end_unique = unique(words.begin(), words.end())//返回指向不重複區域以後一個位置的迭代器
      words.erase(end_unique, words.end());
  }

定製操做

• 向算法傳遞函數

  bool isShorter(const string &s1, const string &s2){
      return s1.size() < s2.size();
  }
  sort(words.begin(), words.end(), isShorter);
  elimDups(words);
  stable_sort(words.begin(), words.end(), isShorter);
  for(const auto &s:words)//無須拷貝字符串
  	cout << s << " " ;
  cout << endl;

• lambda表達式(一個返回類型，一個參數列表，一個函數體)

  void biggies(vector<string> &words,
  			vector<string>::size_type sz)
  {
      elimDups(words);
      stable_sort(words.begin(), words.end(), isShorter);
  }
  //lambda
  [capture list](parameter list) -> return type { function body }
  auto f = []{return 42; }
  [](const string &s1, const string &s2){ return s1.size() < s2.size(); }
  [sz](const string &a){ return a.size() >= sz; }
  auto wc = find_if(words.begin(), words.end(),
  			[sz](const string &a)
  				{return a.size() >= sz;})
  for_each(wc, words.end(),
  	[](const string &s){cout << s << " ";});
  cout << endl;

  lambda捕獲和返回

  • 值捕獲
  • 引用捕獲
  • 隱式捕獲
    建議：儘可能保持lambda的變量捕獲簡單化
    可變lambda：加上mutable
    指定lambda返回類型：transform

• 參數綁定bind

  auto check6 = bind(check_size(), _1, 6);
  sort(words.begin(), words.end(), bind(isShorter, _2, _1));//重排參數順序
  for_each(words.begin(), words.end(), bind(print, ref(os), _1, ' '));//綁定引用參數

再探迭代器

• insert iterator:插入元素，it = t, *it, ++it, it++
  back_inserter:建立一個使用push_back的迭代器
  front_inserter:使用push_front的迭代器
• iostream迭代器
  istream_iterator
  ostream_iterator
• 反向迭代器

迭代器類別

• 輸入迭代器：==,!=；++；*；->
• 輸出迭代器：++;*
• 前向迭代器：只能沿一個方向移動，replace|forward_list
• 雙向迭代器：--,reverse
• 隨機訪問迭代器：<,<=,>,>=；+,+=,-=；-；下標運算符

特定容器算法

lst.merge(lst2)
lst.merge(lst2, comp)
list.remove(val)
lst.remove_if(pred)
list.reverse()
lst.sort()
lst.sort(comp)
lst.unique()
lst.unique(pred)
lst.splice(args)
//鏈表特有的操做會改變容器，如remove,unique,merge，splice

ch11 關聯容器

關聯容器中的元素是按關鍵字保存和訪問的

主要是map和set

map,set,multimap,multiset,unordered_map,unordered_set,unordered_multimap,unordered_multiset

pair標準庫類型

有序容器：使用比較運算符組織元素

關聯容器操做

//map的value_type是一個pair，能夠改變值，但不能改變關鍵字成員的值
//set的迭代器是const的
auto map_it = word_count.cbegin();
while(map_it != word_count.cend())
{
    cout << map_it->first << map_it->second << endl;
    ++map_it;
}
//添加元素
set.insert(ivec.cbegin(), ivec.cend());
set.insert({1,2,3});
word_count.insert({word,1});
word_count.insert(make_pair(word,1));
word_count.insert(pair<string,size_t>(word,1));
word_count.insert(map<string,size_t>::value_type(word,1));
//insert操做
c.insert(v);
c.emplace(args)
c.insert(b,e)
c.insert(il)
c.insert(p,v)
c.emplace(p,args)
//multimap
multimap<string,string> authors;
authors.insrt({"Barth,John","Factor"});

//刪除元素
c.erase(k)
c.erase(p)
c.erase(b,e)

//訪問元素
c.find(k)
c.count(k)
c.lower_bound(k)
c.upper_bound(k)
c.equal_range(k)
string search_item("Alain de Botton");
auto entries = authors.count(search_item);
auto iter = authors.find(search_item);
while(entries)
{
    cout << iter->second << endl;
    ++iter;
    entries--;
}
for(auto beg = authors.lower_bound(search_item), end = authors.upper_bound(search_item);
		beg != end; ++beg)
{
    cout << beg->second << endl;
}
//equal_range
for(auto pos = authors.equal_range(search_item); pos.first != pos.end; ++pos.first)
{
    cout << pos.first->second << endl;
}

對map使用find代替下標操做

無序容器：使用哈希函數和關鍵字類型的==運算符，存儲上組織爲一組桶，哈希函數將元素映射到桶

size_t hasher(const Sales_data &sd)
{
    return hash<string>()(sd.isbn());
}
bool eqOp(const Sales_data &lhs, cont Sales_data &rhs){
    return lhs.isbn() == rhs.isbn();
}

ch12 動態內存

靜態內存：局部static對象、類static數據成員、定義在函數以外的變量。

棧內存：保存定義在函數內的非static對象

內存池（堆）：存儲動態分配的對象，且顯式銷燬

• shared_ptr類（模板）
  默認初始化的智能指針中保存着一個空指針

  if(p1 && p1->empty())
  	*p1 = "hi";
  //shared_ptr和unique_ptr都支持
  shared_ptr<T> sp
  unique_ptr<T> sp
  p
  *p
  p->mem
  p.get()//p中保存的指針
  swap(p,q)//交換指針
  p.swap(q)
  //shared_ptr獨有
  make_shared<T>(args)
  shared_ptr<T>p(q)
  p = q
  p.unique()
  p.use_count()//用於調試

  • make_shared
    最爲安全 auto p6 = make_shared<vector >();

  • 拷貝賦值
    shared_ptr都有一個引用計數。

    auto r = make_shared<int>(42);
    r = q;//遞增q指向對象的引用計數，遞減r的引用計數，r原來指向的對象自動銷燬

  • 自動釋放相關聯的內存

    shared_ptr<Foo> factory(T arg)
    {
        rdturn make_shared<Foo>(arg);
    }
    shared_ptr<Foo> use_factory(T arg)
    {
        shared_ptr<Foo> p = factory(arg);
        return p;//返回p時，引用計數遞增
    }

  • 使用了動態生存期的資源的類

    1. 程序不知道本身須要使用多少對象（容器類）

    2. 程序不知道所需對象的準確類型（ch15）

    3. 程序須要在多個對象中共享數據

       Blob<string> b1;
       {
           Blob<string> b2 = {"a","aa","aaa"};
           b1 = b2;//b1和b2共享底層數據，b2被銷燬，但b2中的元素不能銷燬   
       }

  • StrBlob

  • 直接管理內存

    int *p1 = new int;//分配失敗，拋出std::bad_alloc
    string *ps = new string(10,'9');
    auto p1 = new auto(obj);
    const int *pci = new const int(1025);
    delete p;
    int i, *pi1 = &i, *pi2 = nullptr;
    double *pd = new double(33), *pd2 = pd;
    delete i;//false
    delete pi1;//undefined
    delete pd;//true
    delete pd2;//undifined
    delete pi2;//true

    由內置指針管理的動態內存在顯式釋放前都會存在
    new和delete管理內存存在三個問題：

    1. 忘記delete
    2. 使用已經釋放掉的內存
    3. 同一塊內存釋放兩次

  • shared_ptr和new結合使用

    //接受指針參數的智能指針構造函數是explicit
    shared_ptr<int> p1 = new int(1025);//wrong
    shared_ptr<int> p2(new int(1025));true
    shared_ptr<int> clone(int p){
        return shared_ptr<int>(new int (p));
    }
    
    //定義和改變shared_ptr
    shared_ptr<T> p(q)
    shared_ptr<T> p(u)
    shared_ptr<T> p(q,d)
    shared_ptr<T> p(p2,d)
    p.rerset()
    p.reset(q)
    p.reset(q,d)

    不要混合使用智能指針和普通指針
    不要使用get初始化另外一個智能指針或爲智能指針賦值

    shared_ptr<int> p(new int(42));
    int *q = p.get();
    {
        shared_ptr<int>(q);
    }
    imt foo = *p;//未定義，p指向的內存已釋放

    reset更新引用計數，常常與unique一塊兒使用
    if(!p.unique())
    p.reset(new string(*p));
    *p += newVal;

  • 智能指針與異常
    智能指針陷阱：

    1. 不使用相同的內置指針值初始化(或reset)多個智能指針
    2. 不delete get()返回的指針
    3. 不適用get()初始化或reset另外一個智能指針
    4. 使用get()返回的指針，最後一個對應的智能指針銷燬後，指針變爲無效
    5. 使用智能指針，傳遞一個刪除器

• unique_ptr
  unique_ptr不支持拷貝和賦值

  //unique_ptr支持的操做
  unique_ptr<T> u1
  unique_ptr<T,D> u2
  unique_ptr<T,D> u(d)
  u = nullptr
  u.release()
  u.reset()
  u.reset(q)
  u.reset(nullptr)

  拷貝或賦值一個將要被銷燬的unique_ptr參數

  unique_ptr<int> clone(int p){
      return unique_ptr<int>(new int(p));
  }
  unique_ptr<int> clone(int p){
      unique_ptr<int> ret(new int(p));
      //...
      return ret;
  }
  //傳遞刪除器
  unique_ptr<objT, delT> p(new objT, fcn);
  void f(destination &d)
  {
      connection c = connect(&d);
      unique_ptr<connection, decltype(end_connection)*> p(&c,end_connection);
      //使用鏈接，且f退出時，connection會被關閉
  }

• weak_ptr
  不控制所指向對象生存期的智能指針，指向一個shared_ptr管理的對象，不會改變shared_ptr的引用計數。

  weak_ptr<T> w
  weak_ptr<T> w(sp)
  w = p
  w.reset()
  w.use_count()
  w.expired()
  w.lock()
  
  auto p = make_shared<int>(42);
  weak_ptr<int> wp(p);
  if(shared_ptr<int> np = wp.lock())
  //...

大多數應用應該使用標準庫容器而不是動態分配的數組，使用容器更不容易出線內存管理錯誤且可能有更好的性能。

• new和數組

  int *p = new int(get_size());

• allocator類

  allocator<T> a
  a.allocate(n)
  a.deallocate(p,n)
  a.construct(p,args)
  a.destroy(p)
  
  uninitialized_copy(b,e,b2)
  uninitialized_copy_n(b,n,b2)
  uninitialized_fill(b,e,t)
  uninitialized_fill_n(b,n,t)

ch13 拷貝控制

• 拷貝構造函數

  class Foo {
      public:
      Foo();
      Foo(const Foo&);
  }

  合成~：

  1. 類類型成員：使用其拷貝構造函數

  2. 內置類型：直接拷貝

  3. 對於數組，若是不是類類型，則逐元素拷貝；不然按照元素拷貝構造函數拷貝

     class Sales_data{
     public:
     Sales_data(const Sales_data&);
     private:
     std::string bookNo;
     int units_sold = 0;
     double revenue = 0.0;
     }
     Sales_data::Sales_data(const Sales_data &orig):
     bookNo(orig.bookNo),
     units_sold(orig.units_sold),
     revenue(orig.revenue)
     {}
     //拷貝初始化
     string dots(10, '.');//直接初始化
     string s(dots);//直接初始化
     string s2 = dots;//拷貝初始化
     string nullbook = "9-99-99999-9";//拷貝初始化
     string nines = string(100, '9');//拷貝初始化

  拷貝發生在：

  1. =定義變量

  2. 將一個對象從實參傳遞給非引用類型的形參

  3. 從一個返回類型爲非引用類型的函數返回一個對象

  4. 花括號初始化一個數組或一個struct
     當傳遞一個實參或從函數返回一個值時，不能隱式使用一個explicit構造函數。

     vector v1(10);//true
     vector v2 = 10;//wrong,構造函數explicit
     void f(vector );
     f(10);//wrong,不能用explicit構造函數拷貝一個實參
     f(vector (10));//true

  編譯器能夠繞過拷貝構造函數

• 拷貝賦值運算符
  重載運算符：本質上是函數，由operator後接運算符符號。

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

  合成拷貝賦值運算符

  Sales_data&
  Sales_data::operator=(const Sales_data &rhs){
      bookNo = rhs.bookNo;
      units_sold = rhs.units_sold;
      revenue = rhs.revenue;
      return *this;
  }

• 析構函數
  析構函數不接受參數，不能重載
  析構函數被調用：

  1. 變量離開做用域被銷燬
  2. 當以額對象被銷燬時，其成員被銷燬
  3. 容器被銷燬時，其元素被銷燬
  4. 動態分配的對象，指向它的指針用delete被銷燬
  5. 臨時對象，建立它的表達式結束時被銷燬
     當指向一個對象的引用或指針離開做用域時，析構函數不會執行
     析構函數體不直接銷燬成員，而是在析構函數體以後隱含的析構階段被銷燬

• 三/五原則
  若是一個類須要析構函數，那麼必然須要拷貝構造和拷貝賦值函數

  class HasPtr{
  public:
  	HasPtr(const std::string &s = std::string()):
  	ps(new std::string(s)),i(0){}
  	~HasPtr(){delete ps;}
  	//wrong,HasPtr須要一個拷貝構造和拷貝賦值
  }
  //賦值
  HasPtr f(HasPtr hp)
  {
      HasPtr ret = hp;
      return ret;
  }
  //hp和ret都被銷燬，致使ps被析構兩次
  HasPtr p("some values");
  f(p);//f結束時，p.ps被析構
  HasPtr q(p);//q和p都指向無效內存

  拷貝構造和拷貝賦值是共生的

• 使用=defalut
  咱們只能對具備合成版本的成員函數使用=defalut(默認構造，拷貝控制成員)

• 阻止拷貝
  =delete通知編譯器，咱們不但願定義這些成員。咱們能夠對任何函數指定，主要用途是禁止拷貝控制成員。
  析構函數不能=delete

• 合成拷貝控制成員多是刪除的

  1. 類的某個成員的析構函數是刪除的或private
  2. 拷貝構造函數是刪除的或private
  3. 拷貝賦值運算符是刪除的或private
  4. 類有一個引用成員，沒有類內初始化器，或有一個const成員，沒有類內初始化器，則默認構造函數是刪除的

類的行爲像一個值，意味着它應該有本身的狀態，副本與原對象徹底獨立。如標準庫容器和string類

類的行爲像一個指針，共享狀態。副本和原對象使用相同的底層數據。如shared_ptr

IO和unique_ptr不容許拷貝和賦值，既不是指針也不是值

• 類值

  class HasPtr{
  public:
  	HasPtr(const std::string &s = std::string()):
  	ps(new std::string(s)),i(0){}
  	HasPtr(const HasPtr &p):
  	ps(new std::string(*p.ps)), i(0){}
  	HasPtr& operator=(const HasPtr &);
  	~HasPtr(){delete ps;}
  private:
  	std::string *ps;
  	int i;
  }
  HasPtr& HasPtr::operator=(const HasPtr &rhs){
      auto newp = new string(*rhs.ps);
      delete ps;
      ps = newp;
      i = rhs.i;
      return *this;
  }
  //note
  //若是一個對象賦予它自身，賦值運算符必須正常工做
  //大多數賦值運算符組合了析構函數和拷貝構造函數的工做

• 類指針

  class HasPtr{
  public:
  	HasPtr(const std::string &s = std::string()):
  	ps(new std::string(s)),i(0),use(new std::size_t(1)){}
  	HasPtr(const HasPtr &p):
  	ps(new std::string(*p.ps)), i(p.i), use(p.use{++*use;}
  	HasPtr& operator=(const HasPtr &);
  	~HasPtr();
  private:
  	std::string *ps;
  	int i;
  }
  HasPtr::~HasPtr()
  {
      if(--*use == 0)
      {
          delete ps;
          delete use;
      }
  }
  HasPtr& HasPtr::operator=(const HasPtr &rhs)
  {
  	++*rhs.use;
  	if(--*use == 0)
  	{
          delete ps;
          delete use;
  	}
  	ps = rhs.ps;
  	i = rhs.i;
  	use = rhs.use;
  	return *this;
  }

swap

拷貝控制示例

動態內存管理類

對象移動

//右值引用
int i = 42;
int &r = i;//true
int &&rr = i;//wrong
int &r2 = i*42;//wrong
const int &r3 = i*42;//true
int &&rr2 = i*42;//true

右值引用：所引用的對象即將銷燬；對象沒有其餘用戶

顯示將左值轉換成右值引用：int &&rr3 = std::move(rr1);

StrVec::StrVec(StrVec &&s) noexcept//承諾不拋出異常
: elements(s.elements), first_free(s.first_free),cap(s.cap)
{
    s.elements = s.first_free = s.cap = nullptr;
}
StrVec &StrVec::operator=(const StrVec &&rhs) noexcept
{
    if(this != &rhs)
    {
        free();
        elements = rhs.elements;
        first_free = rhs.first_free;
        cap = rhs.cap;
        rhs.elements = rhs.first_free=rhs.cap = nullptr;
    }
    return *this;
}

ch14 重載運算與類型轉換

• 基本概念
  一元運算符有一個，二元運算符有兩個參數。operator()含有默認實參

  • 賦值=、下標[]、調用()和成員訪問箭頭->必須是成員
  • 複合賦值運算符通常來講是成員
  • 遞增、遞減和解引用運算符，一般應該是成員
  • 對稱性的運算符，如算術、相等、關係、位運算等，則爲普通的非成員函數

• 輸入和輸出運算符

  ostream &operator<<(ostream &os, const Sales_data &item)
  {
      os << item.isbn();
      return os;
  }
  //輸入輸出運算符必須是非成員函數
  istream &operator>>(istream &is, Sales_data &item)
  {
  	double price;
  	is >> item.bookNo >> item.units_sold >> price;
  	if(is)
  		item.revenue = item.units_sold * price;
  	else
  		item = Sales_data();
  	return is;
  }

• 算術和關係運算符
  定義成非成員函數

  • 相等運算符

    bool operator==(const Sales_data &lhs, const Sales_data &rhs)
    {
        return lhs.isbn() == rhs.isbn() &&
        		lhs.units_sold == rhs.units_sold &&
        		lhs.revenue == rhs.revenue;
    }
    bool operator!=(const Sales_data &lhs, const Sales_data &rhs)
    {
        return !(lhs == rhs);
    }

    1. 若是一個類含有判斷兩個對象是否相等的操做，則它應該把函數定義成operator==而非一個普通的命名函數
    2. 若定義了operator==，則應該可以斷定一組給定對象中是否含有重複數據
    3. 同時應該定義!=
    4. ==和!=應該把工做託管給其中一個

  • 關係運算符
    定義operator<比較有用

    1. 定義順序關係，使得與關聯容器中對關鍵字的要求一致
    2. 類同時有運算符，定義一種關係使得與保持一致
       若是存在惟一一種邏輯可靠的<定義，則應該考慮定義<，若同時包含，當且僅當<與產生的結果一致才定義

• 賦值運算符
  複合賦值運算符

  Sales_data& Sales_data::operator+=(const Sales_data &rhs)
  {
      units_sold += rhs.units_sold;
      revenue += rhs.revenue;
      return *this;
  }

• 下標運算符（成員函數）

  class StrVec{
      public:
      std::string& operator[](std::size_t n)
      { return elements[n]; }
  	const std::string& operator[](std::size_t n)const
  	{ return elements[n]; }
  	private:
  	std::string *elements;
  }

• 遞增/遞減運算符

  //前置
  class StrBlobPtr{
  public:
  	StrBlobPtr& operator++();
  	StrBlobPtr& operator--();
  };
  StrBlobPtr& StrBlobPtr::operator++()
  {
      check(curr,"increment past end of StrBlobPtr");
      ++curr;
      return *this;
  }
  StrBlobPtr& StrBlobPtr::operator--()
  {
  	--curr;
      check(curr,"increment past begin of StrBlobPtr");
      return *this;
  }
  //後置
  class StrBlobPtr{
  public:
  	StrBlobPtr& operator++(int);
  	StrBlobPtr& operator--(int);
  };
  StrBlobPtr& StrBlobPtr::operator++(int)
  {
      StrBlobPtr ret = *this;
      ++*this;
      return ret;
  }
  StrBlobPtr& StrBlobPtr::operator--()
  {
  	StrBlobPtr ret = *this;
  	--*this;
      return ret;
  }

• 成員訪問運算符

  class StrBlobPtr{
      public:
      std::string& operator*()const
      { auto p = check(curr, "dereference past end");
      	return (*p)[curr];
      }
      std::string* operator->()const
      {
          return & this->operator*();
      }
  }

• 函數調用運算符

• 重載、類型轉換與運算符

ch15 面向對象程序設計

OOP(object-oriented programming)核心思想是數據抽象、繼承和動態綁定。

• 抽象：接口和實現分離
• 繼承：定義類似的類型並對類似關係建模
• 動態綁定：必定程度上忽略類型的卻別，以統一的方式使用他們的對象
  使用基類的引用/指針調用一個虛函數將發生動態綁定

OOP的核心思想是多態。引用/指針的靜態類型和動態類型不一樣正是C++支持多態的根本所在

基類與派生類

class Quote{
public:
	Quote() = default;
	Quote(const std::string &book, double sales_price):
	bookNo(book),price(sales_price){}
	std::string isbn()const {return bookNo;}
	virtual double net_price(std::size_t n)const
	{
        return n * price;
	}
	virtual ~Quote() = default;
private:
	std::string bookNo;
protected:
	double price = 0.0;
};
class Bulk_quote : public Quote{
public:
	Bulk_quote() = default;
	Bulk_quote(const string&, double, std::size_t, double);
	double net_price(std::size_t)const override;
private:
	std::size_t min_qty = 0;
	double discount = 0.0;
}
//派生類到基類的隱式轉換
Quote item;
Bulk_quote bulk;
Quote *p = &item;
p = &bulk;
Quote &r = bulk;

Bulk_quote(const std::string book, double p,std::size_t qty, double disc):
Quote(book,p),min_qty(qty),discount(disc){}//首先初始化基類，而後按照聲明順序初始化

繼承與靜態成員：只存在該成員惟必定義

防止繼承發生：final

• 虛函數
  對虛函數的調用直到運行時才被解析。
  經過做用域運算符能夠強行調用基類虛函數
• 抽象基類
  含有純虛函數=0的類是抽象基類。不能直接建立一個抽象基類對象。
• 訪問控制和繼承
  protected:
  • 和私有成員相似，受保護的成員對於類的用戶是不可訪問的
  • 與公有成員相似，受保護的成員對於派生類的成員和友元是可訪問的
• 繼承中的類做用域
  派生類成員隱藏同名基類成員
  p->mem()
  1. 首先肯定p的靜態類型。
  2. p的靜態類型對應的類內趙mem，若是找不到，則在直接基類內查找直至繼承鏈的頂端，仍是找不到編譯器報錯。
  3. 找到了mem，進行類型檢查
  4. 若mem是虛函數，經過引用/指針調用，則在運行時肯定到底運行虛函數的哪一個版本
  5. 反之，如果經過對象或不是虛函數，則產生一個常規函數調用
• 構造函數與拷貝控制
  虛析構函數 = default，阻止合成移動操做
  合成拷貝控制與繼承
  派生類的拷貝控制成員
  繼承的構造函數
• 容器與繼承

ch16 模板與泛型編程

• 定義模板

  template <typename T>
  int compare(const T &v1, const T &v2)
  {
      if(v1 < v2) return -1;
      if(v2 < v1) return 1;
      return 0;
  }
  template <typename T>
  T foo(T* p)
  {
      T tmp = *p;
      return tmp;
  }
  template <typename T, class U> calc(const T&, const U&);

  非類型模板參數
  inline和constexpr的函數模板

  template <typename T> int compare(const T &v1, const T &v2)
  {
      if(less<T>()(v1,v2)) return -1;
      if(less<T>()(v1,v2)) return 1;
      return 0;
  }

  類模板

  • 默認狀況下，對於一個實例化了的類模板，其成員只有在使用時才被實例化

  • 類模板做用域內，能夠直接使用模板名而沒必要指定模板實參

  • 類模板與友元：一對一（BlobPtr 能夠訪問Blob ，而不能訪問Blob ）,通用/一對多，模板本身的類型成爲友元

  • 類模板的static：每一個實例都有惟一一個static對象
    模板參數

  • 當咱們但願通知編譯器一個名字表示類型時，必須使用typename，而不能使用class

  • 默認模板實參

    template <typename T, typename F = less<T>>
    int compare(const T &v1, cosnt T &v2,F f = F())
    {
        if(f(v1,v2)) return -1;
        if(f(v2,v1)) return 1;
        return 0;
    }

  成員模板(不能是虛函數)

  • template <typename T> class Blob{
        template <typename It> Blob(It b, It e);
    };
    template <typename T>
    template <typename T>
    	Blob<T>::Blob(It b, It e):data(std::make_shared_ptr<std::vector<T>>(b,e)){}

  控制實例化

  • 多文件中實例化相同模板的開銷很是嚴重，能夠經過顯式實例化避免開銷。

    extern template class Blob<string>;
    template int compare(const int&, const int&);

  • 在一個類模板的實例化定義中，所用類型必須可以用於模板的全部成員函數
    效率和靈活性

  • 運行時綁定刪除器:shared_ptr

  • 編譯時綁定刪除器：unique_ptr

• 模板實參推斷（函數實參->模板實參）
  調用中應用於函數模板

  • const轉換，將一個非const對象的引用傳遞給const引用形參

  • 數組或函數指針轉換

  • 顯式實參

    auto val3 = sum<long,long>(i,lng);
    template <typename T1,typename T2,typename T3>
    T3 alternative_sum(T2,T1);
    auto val2 = alternative_sum(long long,int,int)(i,lng);

  • 尾置返回類型與類型轉換

    //容許咱們在參數列表以後聲明返回類型
    template <typename It>
    auto fcn(It beg, It end)->decltype(*beg)
    {
        return *beg;
    }

  • std::move實現

  • 轉發：若是一個函數參數是指向模板類型參數的右值引用，它對應的實參的const屬性和左值/右值屬性將獲得保持

  • 使用std::forward保持類型

• 重載與模板
  正肯定義一組重載的函數模板須要對類型間的關係和模板函數容許的有限的實參類型轉換有深入的理解。

• 可變參數模板

  • 模板參數包：0個/多個模板參數

    //Args是模板參數包，rest是函數參數包
    template <typename T, typename... Args>
    void foo(const T &t, const Args&... rest);
    //sizeof...運算符返回包中元素

  • 函數參數包：0個/多個函數參數

  • 包擴展

  • 轉發參數包

• 模板特例化(本質是實例化一個模板)

  template<>
  int compare(const char* const &p1, const char* const &p2)
  	return strcmp(p1,p2);
  namespace std{
      template<>
      struct hash<Sales_data>
      {
          typedef size_t result_type;
          typedef Sales_data argument_type;
          size_t operator()(const Sales_data& s)const;
      };
      size_t
      hash<Sales_data>::operator()(const Sales_data &s)const
      {
          return hash<string>()(s.bookNo) ^
          		hash<unsigned>()(s.units_sold) ^
          		hash<double>()(s.revenue);
      }
  }

  部分特例化類模板，而不能部分特例化函數模板 特例化成員而不是類