C++(八股文) —— static、this指针、inline、volatile、assert、explicit

1、static

作用

1. 修饰普通变量，修改变量的存储区域和生命周期，使变量存储在静态区，在main函数运行前就分配了空间，如果有初始值就用初始值初始化它。

static  int  temp = 10;

2. 修饰普通函数，表名函数的作用范围，仅在定义该函数的文件内才能使用。在多人开发项目时，为了防止与他人命名空间里的函数重名，可以将函数定为static。

static  void fun(){std::cout << "是 The Lin 呀" << std::endl;}

3. 修饰成员变量，使所有的对象只保存一个该变量，而且不需要生成对象就可以访问该成员。

class student{
	public:
		static std::string name = "The Lin";
}

4. 修饰成员函数，修饰成员函数使得不需要生成对象就可以访问该函数，但是在static函数内不能访问非静态成员。

class student{
	public:
		static std::string name = "The Lin";
	private:
		static void funtion(){std::cout << name << std::endl;}
}

2、this 指针

1. this 指针是一个隐含于每一个非静态成员函数中的特殊指针。它指向调用该成员函数的那个对象

2. 当对一个对象调用成员函数时，编译程序先将对象的地址赋给 this 指针，然后调用成员函数，每次成员函数存取数据成员时，都隐式使用this指针。

3. this指针被隐含地声明为: ClassName * const this ，这意味着不能给 this 指针赋值，在 ClassName 类的 const 成员函数中，this指针的类型为：const ClassName* const，这说明 this 指针所指向的对象是不可修改的(即不能对这种对象的数据成员进行赋值操作)

class student{
	public:
		void funtion() const;
		//fun函数被限定不能修改所属对象的成员变量的值
	private:
		std::string name = "The Lin";
}

4. this 并不是一个常规变量，而是个右值，所以不能取得 this 的地址(不能&this)
5. 在以下场景中，经常需要显式引用this指针
   5.1 为实现对象额链式引用
   5.2 为避免对同一对象进行赋值操作
   5.3 在实现一些数据结构时，如list

3、inline 内联函数

作用

1. 相当于把内联函数里面的内容写在调用内联函数处
2. 不用执行进入函数的步骤，直接执行函数体
3. 相当于宏，却比宏多了类型检查，真正具有函数特性
4. 编译器一般不内联包含循环、递归、switch等复杂操作的内联函数
5. 在类声明中定义的函数，除了虚函数的其他函数都会自动隐式地当成内联函数

// 声明1（加 inline，建议使用）
inline int functionName(int first, int second,...);

// 声明2（不加 inline）
int functionName(int first, int second,...);

// 定义
inline int functionName(int first, int second,...) {/****/};

// 类内定义，隐式内联
class A {
    int doA() { return 0; }         // 隐式内联
}

// 类外定义，需要显式内联
class A {
    int doA();
}
inline int A::doA() { return 0; }   // 需要显式内联

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

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

优缺点
优点：

1. 内联函数用宏函数一样将在被调用处进行代码展开，省去了参数压栈、栈帧开辟与回收，结果返回等，从而提高程序运行速度

2. 内联函数相比宏函数来说，在代码展开时，会做安全检查或自动类型转换(同普通函数)，而宏定义则不会

3. 在类中声明同时定义的成员函数，自动转化为内联函数，因此内联函数可以访问类的成员变量，宏定义不能4.内联函数在运行时可调试，而宏定义不能

4. 内联函数在运行时可调试，而宏定义不能

缺点：

1. 代码膨胀。内联时以代码膨胀(复制)为代价，消除函数调用带来的开销。如果执行函数体内代码的时间，相比于函数调用的开销较大，那么效率的收获会很少。另一方面，每一处内联函数的调用都要复制代码，将使程序的总代码量增大，消耗更多的内存空间。
2. inline 函数无法随着函数库升级而升级。inline函数的该表需要重新编译，不像 non-inline 可以直接链接
3. 是否内联，程序员不可控，内联函数只是对编译器的建议，是否对函数内联，决定权在于编译器

4、volatile

volatile int i = 10; 

1. volatile 关键字是一种类型修饰符，用它声明的类型表示可以被某些编译器未知的因素(操作系统、硬件、其他线程)更改。所以使用volatile 告诉编译器不应对这样的对象进行优化。
2. volatile 关键字声明的遍历，每次访问时都必须从内存中取出值(没有被valatile 修饰的变量，可能由于编译器的优化，从CPU寄存器中取值)
3. const 可以是 volatile (如只读的状态寄存器)
4. 指针可以是 volatile

5、assert

  断言，是宏，而非函数。assert宏的原型定义在<assert.h>©、(C++)中，其作用是如果它的条件返回错误，则终止程序执行。可以通过定义 NDEBUG 来关闭assert，但需要在源代码的开头，include<assert.h>

#define NDEBUG          // 加上这行，则 assert 不可用
#include <assert.h>
assert( p != NULL );    // assert 不可用

6、explicit(显示)

1. explicit 修饰构造函数，可以防止隐式转换和复制初始化
2. explicit 修饰转换函数，可以防止隐式转换，但 按语境转换 除外

struct A
{
	A(int) { }
	operator bool() const { return true; }
};

struct B
{
	explicit B(int) {}
	explicit operator bool() const { return true; }
};

void doA(A a) {}

void doB(B b) {}

int main()
{
	A a1(1);		// OK：直接初始化
	A a2 = 1;		// OK：复制初始化
	A a3{ 1 };		// OK：直接列表初始化
	A a4 = { 1 };		// OK：复制列表初始化
	A a5 = (A)1;		// OK：允许 static_cast 的显式转换 
	doA(1);			// OK：允许从 int 到 A 的隐式转换
	if (a1);		// OK：使用转换函数 A::operator bool() 的从 A 到 bool 的隐式转换
	bool a6(a1);		// OK：使用转换函数 A::operator bool() 的从 A 到 bool 的隐式转换
	bool a7 = a1;		// OK：使用转换函数 A::operator bool() 的从 A 到 bool 的隐式转换
	bool a8 = static_cast<bool>(a1);  // OK ：static_cast 进行直接初始化

	B b1(1);		// OK：直接初始化
	B b2 = 1;		// 错误：被 explicit 修饰构造函数的对象不可以复制初始化
	B b3{ 1 };		// OK：直接列表初始化
	B b4 = { 1 };		// 错误：被 explicit 修饰构造函数的对象不可以复制列表初始化
	B b5 = (B)1;		// OK：允许 static_cast 的显式转换
	doB(1);			// 错误：被 explicit 修饰构造函数的对象不可以从 int 到 B 的隐式转换
	if (b1);		// OK：被 explicit 修饰转换函数 B::operator bool() 的对象可以从 B 到 bool 的按语境转换
	bool b6(b1);		// OK：被 explicit 修饰转换函数 B::operator bool() 的对象可以从 B 到 bool 的按语境转换
	bool b7 = b1;		// 错误：被 explicit 修饰转换函数 B::operator bool() 的对象不可以隐式转换
	bool b8 = static_cast<bool>(b1);  // OK：static_cast 进行直接初始化

	return 0;
}