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);
      }
  }

  部分特例化类模板，而不能部分特例化函数模板 特例化成员而不是类