C++基础知识复习

第一部分：基础知识

一、const

1. 作用

修饰变量，表示不可能更改
修饰指针
- const int *ptr——pointer to const
- int const *ptr—— const pointer
- 原则：被const修饰的后面的值是不可改变的
修饰引用

常用于形参。即避免了copy，又避免了对其值的修改
修饰成员函数

表示该成员函数不能修改成员变量

二、static

1. 作用

修饰普通变量

修改变量的存储区域，使其存储在静态区。

在main函数执行前就分配了空间；

如果没有被显式初始化，则用默认值初始化
修饰普通函数

表明函数的作用范围。

仅在定义该函数的文件内才能使用（多人项目中，为了防止与其他namespace重名，可以将函数定义为static）
修饰成员变量

使其变为类变量，即所有instance公用一个变量
修饰成员函数

使得不需要构造对象就可以访问此函数

static函数内不能访问非静态成员（毕竟人家不要构造实例）

三、this指针

this指针是一个隐含于每一个非静态成员函数中的特殊指针，指向调用该成员函数的那个对象。（类似ptyhon类中的self）
当对一个对象调用成员函数时，程序先讲对象的地址赋给this指针，然后调用成员函数；每次成员函数存取数据变量时，都隐式地使用this指针
this指针被隐式地声明为ClassName *const this——意味着不能给this指针赋值；在ClassName类的const成员函数中，this指针的类型为：const ClassName* const，这说明不能修改this指针指向的数据成员。
this并不是一个常规变量，而是一个右值，所以不能取得this的地址（能不能&this）
以下场景中，经常显式的引用this指针：
- 为实现对象的链式引用
- 为避免对同一对象进行赋值操作
- 为实现一些数据结构时，如list

四、inline内连函数

1. 特点

编译时，将内联函数内容在调用处展开
省略了进入函数的步骤，直接执行函数体
类似于宏，但多了类型检查，具有函数特性
编译器一般不inline包含循环、递归、switch等复杂操作的函数
类中定义的函数，除了虚函数之外，其他函数都会自动隐式地的当成内联函数。

2. 编译器对inline函数的处理步骤

将inline函数体复制到inline函数调用处
为所有inline函数中的局部变量分配内存空间
将inline函数的输入参数和返回值映射到调用方法的局部变量中
如果inline函数包括多个返回点，将其转变为inline函数代码块末尾的分支（使用GOTO）

3. 优点

省去了参数压栈、栈帧开辟与回收，结果返回的开销
相比与宏来讲，在代码展开时，会做安全检查或者自动类型转换
在类中声明同时定义的成员函数，会自动inline，因此内联函数可以访问类的成员变量，但宏不可以
内联函数在运行时可调试，宏定义不可以

4. 缺点

代码膨胀。若执行函数体的时间比函数调用大很多，则inline收益很小。
inline无法随着函数库升级而升级。inline函数的改变需要重新编译，而non-inline可以直接连接
是否内联，程序员不可控。inline函数只是对编译器的建议，是否内联，由编译器决定。

5. 虚函数可以是`inline`吗

可以。但当虚函数表现多态时的时候，不能内联
内联发生在编译时，而虚函数的多态性是在运行期，编译器无法知道运行时调用哪个函数。因此虚函数表现为多态时（运行期）不能内联
inline virtual唯一可以内联：编译器知道要调用的对象是哪个类（如Base::who()），这只发生在编译器具有实际对象，而非对象的指针或引用。

例子：

#include <iostream>
using namespace std;
class Base {
  public:
    inline virtual void who(){cout << "Base::who"<<endl;}
    virtual ~Base()}{}
}

class Derived : public Base {
  public:
    void who(){cout << "Derived::who"<< endl;}
}

int main(){
  Base b;
  b.who(); // 此处编译其就知道要调用哪个函数
  
  Base *ptr = new Derived();
  ptr->who();// 多态
  
  delete ptr;
  ptr = nullptr;
  return 0;
}

五、sizeof

对数组，返回整个数组占用的空间大小
对指针，返回指针本身占用的空间大小

六、extern "C"

被extern的函数或变量是extern类型，跨文件访问
被修饰的变量或函数是按照C语言方式编译和链接的

#ifdef __cplusplus
extern "C"{
#endif
  void *memset(void *, int, size_t);
#ifdef __cplusplus
}
#endif

七、union联合

1. 概念

可以有多个数据成员，但在任意时刻只有一个数据成员可以有值。当某个成员被赋值后，其他成员变成未定义状态。

2. 特点

默认为public
可以有构造函数、析构函数
不能含有引用类型成员
不能继承自其他类，不能作为基类
不能包含虚函数
匿名union在定义所在的作用域可以直接访问union成员
匿名union不能包含protected和privated成员
全局匿名union必须是静态的

#include <iostream>
using namespace std;

union UnionTest {
  UnionTest():i(10){}; // 构造函数
  int i;
  double d;
};

static union{ // 全局静态匿名union
  int i;
  double d;
};

int main(){
  UnionTest u;
  
  cout << u.i << u.d << endl;
  
  Union {   // 局部匿名union
    int i;
    double d;
  };
  ::i = 20; // 全局静态union.i值
  
  i = 30;// 局部i
    
  return 0;
}

八、C实现C++类

封装

使用函数指针把属性和方法封装在结构体中
继承

结构体嵌套
多态

父类与子类方法的函数指针不同

九、explicit

修饰构造函数是，防止隐式转换和复制初始化
修饰转换函数时，防止隐式转换，但按语境转换除外

十、friend友元类和友元函数

能访问私有成员
破坏了封装性
友元函数不可传递
友元函数的单向性
友元声明的形式和数量不受限制

十一、using

1. 引入命名空间的一个成员

using namespace_name::name;

2. C++11中派生类重用基类的构造函数

class Derived : public Base{
  public:
  	using Base::Base; 
};

对于基类的每个构造函数，编译器都会生成一个与之对应（形参类列表完全相同）的派生类构造函数。

3. using指示

using namespace std;// 无需为std里的所有名字添加std前缀了

注：

应尽量少用using 指示，会污染命名空间

如果只引入一个成员，且与局部名称冲突了，编译器会发出指示

但如果全导入了，且覆盖了局部名称，编译器不会提示，排查问题较难

十二、::范围解析符

1. 类别

::name全局作用符。

用于类型名称（如类、类成员、成员函数、变量）前。
class::name类作用域符。

用于指定类型的作用域范围是具体某个类的。
namespace::name命名空间作用域符

用于指定类型的作用域范围是某个命名空间的。

int count = 1; // ::count

class A{
  public:
  	static int count = 2; // A::count
};
void foo(){
  int count = 3;
}

十三、引用

1. 左值引用

常规引用，表示对象的身份。

2. 右值引用

右值引用就是必须绑定到右值（一个临时对象、将要销毁的对象）的引用，一般表示对象的值。

右值引用可以实现转移语义（move sementics）和精确传递（perfect forwarding），主要目的有两个：

消除两个对象交互时不必要的对象拷贝，节省存储资源，提升效率
能够更简洁明确地定义泛型函数

3. 引用折叠

X& &、X& &&、X&& &可以折叠为X&
X&& &&可以折叠为X&&

十四、成员初始化列表

1. 优点

更高效

少了一次调用默认构造函数的过程
有些场合必须要初始化列表
- 常量成员
  
  因为常量只能初始化，不能赋值，所以必须放在初始化列表中
- 引用类型
  
  引用必须在定义时初始化，并不能重新赋值
- 没有默认构造函数的类类型
  
  因为使用初始化列表可以不必调用默认构造函数，就可初始化

2. initializer_list

用花括号初始化器初始化一个列表，其中构造函数接受一个std::initializer_list参数

#include <iostream>
#include <vector>
#include <intializer_list>

template<typename T>
struct S{
  std::vector<T> v;
  S(std::initializer_list<T> l): v(l){
    std::cout << "init"<< endl;
  }
  
  void append(std::initializer_list<T> l){
    v.insert(v.end(), l.begin(), l.end());
  }
  
  std::pair<const T*, std::size_t> c_arr() const {
    return {&v[0], v.size()};
  }
};

第二部分：面向对象

一、多态

1. 概念

多态，可以理解为消息以多种形式显示的能力
多态是以封装和继承为基础的
C++多态分类和实现
- 重载多态（Ad-hoc，编译期）
  
  函数重载，运算符重载
- 子类型多态（subtype，运行期）
  
  虚函数
- 参数多态性（parametric，编译期）
  
  类模板、函数模板
- 强制多态（coercion，编译器/运行期）
  
  基本类型转换、自定义类型转换

2. 静态多态

编译期，早绑定

函数重载

class A{
  void foo();
  void foo(int a);
};

3. 动态多态

运行期/晚绑定

虚函数：virtual修饰

普通函数（非类成员函数）不能是虚函数
静态函数（static）不能是虚函数
构造函数不能是虚函数

因为在调用构造函数时，虚表指针并没有在对象的内存空间中，必须要构造函数调用完成时，才会形成虚表指针（重要）
内联函数不能是表现多态时的虚函数

4. 虚析构函数

是为了解决基类的指针指向派生类对象，并用基类的指针删除派生类对象。

Class Base{
  public:
  	Base();
  	virtual ~Base();
};

class Derived : public Base {
  public:
  	...
};

int main(){
  Base *ptr = new Derived();
  delete ptr;
  ptr = nullptr;
  return 0;
}

5. 纯虚函数

一种特殊的虚函数。

在基类中不能对虚函数给出有意义的实现，而是声明为纯虚函数，它的实现留给派生类去做。

Class AbstraceBase{
  virtual void foo(int) = 0;
};

虚函数 vs 纯虚函数

类如果声明虚函数，且实现了，哪怕是空实现，则作用就是为了能让这个函数在派生类里被override。这样，编译器就可以使用后期绑定来达到多态了；纯虚函数只是一个接口，是个函数声明而已，要留到子类实现
虚函数在派生类可以不重写；纯虚函数必须在子类实现才可以实例化
虚函数的类用于实作继承，继承接口的同时也继承了父类的实现。纯虚函数关注的是接口的统一性，实现由子类去完成
带纯虚函数的类称为抽象类，不能被实例化。只有继承并实现了纯虚函数，才能使用。派生类继承后，可以继续是抽象类，也可以是普通类。
虚基类是虚继承中的基类。

6. 虚函数指针、虚函数表

虚函数指针

在含有虚函数类的对象中，指向虚函数表，在运行时确定
虚函数表

在程序只读数据段.rodata section，存放虚函数指针。如果派生类实现了基类的某个虚函数，则在虚表中覆盖原本基类的那个虚函数指针，在编译时根据类的声明创建。

7. 虚继承

用于解决多继承条件下的菱形继承问题

浪费存储空间、存在二义性

底层实现原理与编译器相关，一般通过虚基类指针和虚基类表实现。每个虚继承的子类都有一个虚基类指针（占用一个指针的存储空间，4字节）和虚基类表（不占用空间）（但虚基类依旧会在子类里面存在拷贝，只是仅仅最多存在一份而已，并不是不在子类里面了）；当虚继承的子类被当做父类继承时，虚基类指针也会被继承。

实际上，vbptr指的是虚基类表指针，指向一个虚基类表——记录了虚基类与本类的偏移地址；通过偏移地址，这样就找到了虚基类成员，而虚继承也不用像普通多继承那样维持公有基类（虚基类）的两份同样拷贝，从而节省了存储空间。

虚继承 vs 虚函数

相同之处

都利用了虚指针（均占用类的存储空间）和虚表（均不占用类的存储空间）
不同之处
- 虚继承
  - 虚基类依旧存在继承类中，之占用存储空间
  - 虚基类表存储的是虚基类的相对直接继承类的偏移
- 虚函数
  - 虚函数不占用存储空间
  - 虚函数表存储的是虚函数地址

模板类、成员模板、虚函数

模板类可以使用虚函数
一个类的成员模板（本身是模板的成员函数）不能是虚函数

8. 抽象类、接口类、聚合类

抽象类：含纯虚函数
接口类：仅含纯虚函数的抽象类
聚合类：可以直接访问其成员，具有特殊的初始化语法
- 所有成员都是public
- 没有定义任何构造函数
- 没有类内初始化
- 没有基类、没有virtual函数

第三部分

一、内存分配和管理

1. malloc、calloc、realloc、alloca

malloc

申请指定字节数的内存。申请到的内存中的初始值不确定
calloc

为指定长度的对象，分配能容纳指定个数的内存。申请的内存的每一位（bit）都初始化为0
realloc

更改以前分配的内存长度（增加或减少）

当增加长度是，可能需要将以前分配区的内容移到另一个足够大的区域。而新增的区域内的初始值不确定
alloca

在栈上申请内存。

程序在出栈时，会自动释放内存。但需注意，alloca不具有可移植性，而且在没有传统堆栈的机器上很难实现。

alloca不宜使用在必须广泛移植的程序中。C99中支持变长数组（VLA），可以用来代替alloca。

2. malloc和free

分别用于内存的分配和释放

// 内存申请
char *str = (char*)malloc(100);
assert(str != nullptr);

// 内存释放
free(str);
str = nullptr;

3. new和delete

new/new[]
- 先底层调用malloc分配内存
- 再调用构造函数（创建对象）
delete/delete[]
- 先调用析构函数（清理资源）
- 再底层调用free释放空间
new申请内存时会自动计算所需要的字节数；malloc则需要我们自己输入申请空间的字节数

int main(){
  T* t = new T(); // 先分配内存，再构造
  delete t; // 先析构，再free
  return 0;
}

4. 定位new

placement new允许我们向new传递额外的地址参数，从而再预先指定的内存区域创建对象。

// place_addr是一个指针
// initializers提供一个以逗号分割的初始值列表
new(place_addr) type;
new(place_addr) type (initializers);
new(place_addr) type [size];
new(place_addr) type [size] {braced intializer list};

5. delete this 合法吗？

合法，但是：

必须保证this对象是通过new（不是new[]、不是placement new、不是栈上、不是全局、不是其他对象成员）分配的
必须保证调用delete this的成员函数是最后一个调用this的成员函数
必须保证成员函数的delete this后面不再调用this了
必须保证delete this后没有人再使用了

总之，delete this对调用的成员函数有很严格的要求。

class A{
  public:
  	A(){};
    void destory(){ delete this;} // 必须显式的调用，进行内存空间释放
  private:
   	~A(){}  // 私有函数，只能通过new去动态构造
};

6. 栈上或堆上生成对象

C++中，类对象的建立有两种：

静态建立
- 如A a;
- 由编译器为对象在栈空间分配内存，是通过移动栈顶指针，挪出适当的空间，然后在这片内存空间上调用构造函数，形成一个栈对象。
- 为什么不把构造函数设置为private?
  
  构造函数设置为私有，会影响new动态建立对象，因为其第二阶段也会调用构造函数。
只能在堆上
- 方法：将析构函数设置为私有
  
  C++是静态绑定语言，编译器管理栈上对象的声明周期。
  
  编译器为类的对象分配栈空间时。会先检查类的析构函数的访问性；
  
  若析构函数不可访问，则不能在栈上创建对象。
- 缺点：无法解决继承问题
  
  若其作为基类，则析构函数一般要设置为virtual，然后在子类重写，以实现多态，所以析构函数不能设置为private。可以将析构函数设置为protected

class A{
  protected:  // protected,解决继承问题
  	A(){}
  	~A(){}
   public:
  	static A* create(){return new A();} // 静态方法，负责创建
  	void destroy() {delete this;}	// 负责释放内存空间，必须最后调用
};

只能在栈上
- 方法：将new和delete重载为private
  在堆上生成对象，使用new关键字操作，过程包括两个阶段：
  1. 使用new在堆上需找可用内存，分配给对象
  2. 调用构造函数生成对象
  将new操作设置为private，那么第一阶段的操作就无法完成，就不能在堆上生成对象

class A{
  private:
  	void *operator new(size_t){}; // 函数第一个参数和返回值都是固定的
  	void operator delete(void* ptr){};// 重载new就需要重载delete
  public:
  	A(){}
  	~A(){}
};

有个问题：

如果既把析构函数设置为private，也将new和delete重载为了private，那么对象会创建在哪里？创建失败？

二、智能指针

1. 标准库

#include <memory>
std::auto_ptr<std::string> ps (new std::string(str));// C++98
// C++ 11中 auto_ptr被弃用

2. shared_ptr

多个智能指针可以共享同一个对象，对象的最末一个拥有者有责任销毁对象，并清理与该对象相关的所有资源。

优点：

支持定制型删除器（custom deleter）
可防范Cross-DLL问题

对象在动态链接库DLL中new创建，却在另一个DLL内被delete销毁
自动解除互斥锁

3. Weak_ptr

允许共享但不拥有某个对象，一旦最末一个拥有该对象的智能指针失去了所有权，任何weak_ptr都会自动成空。

因此，在default和copy构造函数之外，weak_ptr只提供接受一个shared_ptr的构造函数

优点：

可打破环状引用

两个其实已经没有被使用的对象，彼此互指，使之看似还在『被使用』的状态的问题

4. unique_ptr

C++ 11提供的类型，在异常时可以帮助避免资源泄露的智能指针，用于取代auto_ptr

独占式拥有，即一个对象和相应的资源同一时间只被一个pointer拥有。

一旦拥有者被销毁或设置为empty，或开始拥有另一个对象，先前拥有的那个对象就会被销毁，响应资源会被释放。

uique_ptr v.s auto_ptr

auto_ptr可以赋值拷贝，复制拷贝后所有权转移；unique_ptr无赋值拷贝语义，但实现了move语义
auto_ptr对象不能管理数组（析构调用delete）；unique_ptr可以管理数组（析构调用delete[]）

5. 强制类型转换

待补充

附录：

C++面试知识Github

C++基础知识复习

第一部分：基础知识

一、const

1. 作用

二、static

1. 作用

三、this指针

四、inline内连函数

1. 特点

2. 编译器对inline函数的处理步骤

3. 优点

4. 缺点

5. 虚函数可以是inline吗

五、sizeof

六、extern "C"

七、union联合

1. 概念

2. 特点

八、C实现C++类

九、explicit

十、friend友元类和友元函数

十一、using

1. 引入命名空间的一个成员

2. C++11中派生类重用基类的构造函数

3. using指示

十二、::范围解析符

1. 类别

十三、引用

1. 左值引用

2. 右值引用

3. 引用折叠

十四、成员初始化列表

1. 优点

2. initializer_list

第二部分：面向对象

一、多态

1. 概念

2. 静态多态

3. 动态多态

4. 虚析构函数

5. 纯虚函数

6. 虚函数指针、虚函数表

7. 虚继承

8. 抽象类、接口类、聚合类

第三部分

一、内存分配和管理

1. malloc、calloc、realloc、alloca

2. malloc和free

3. new和delete

4. 定位new

5. delete this 合法吗？

6. 栈上或堆上生成对象

二、智能指针

1. 标准库

2. shared_ptr

3. Weak_ptr

4. unique_ptr

5. 强制类型转换

附录：

5. 虚函数可以是`inline`吗