const

const后面的东西为常量

static

修饰普通变量，修改变量的存储区域和生命周期，使变量存储在静态区，在 main 函数运行前就分配了空间，如果有初始值就用初始值初始化它，如果没有初始值系统用默认值初始化它。
修饰普通函数，表明函数的作用范围，仅在定义该函数的文件内才能使用。在多人开发项目时，为了防止与他人命名空间里的函数重名，可以将函数定位为 static。
修饰成员变量，修饰成员变量使所有的对象只保存一个该变量，而且不需要生成对象就可以访问该成员。
修饰成员函数，修饰成员函数使得不需要生成对象就可以访问该函数，但是在 static 函数内不能访问非静态成员。

C++ 类中的static成员的初始化和特点:

#include <iostream>
 
using namespace std;
 
class Test
{
public:
    Test() : y(1), r(y), d(3){} //对于常量型成员变量和引用型成员变量，必须通过参数化列表的方式进行初始化。
    ~Test(){}
 
    int y;      //普通变量成员
    int &r;     //引用成员变量
    const int d;    //常量成员变量
    static int c;   //静态成员变量
    static const int x = 2.1;   //静态常量整型成员变量
    static const int xx;        //静态常量整型成员变量声明
    static const double z;  //静态常量非整型成员变量声明
    static const float zz = 6.6;    //静态常量非整型成员变量

	static void print() {
		c = 150;
		cout << "hello world" << endl;
	}
};
 
 
const int Test::xx = 4; //静态常量整型成员变量定义
const double Test::z = 5.1; 静态常量非整型成员变量定义
int Test::c = 2;
 
int main(void)
{
    cout << Test::x << endl;      	//输出2.1
 	cout << Test::c << endl;		//输出2
 	Test::print();					//输出hello world
 	cout << Test::c << endl;		//输出150
    return 0;
}

这些特殊类型的成员变量主要有：

引用
常量
静态变量
静态整型常量
静态非整型常量

对于1. 引用和2. 常量，成员变量必须通过构造函数的参数列表的方式初始化。例如：上述程序中的r 和 d 变量的初始化。

对于3. 静态变量，static成员变量需要在类定义体外进行初始化与定义，因为static数据成员独立该类的任意对象存在，它是与类关联的对象，不与类对象关联。例如：上述程序中的c变量的初始化。

对于4. 静态整型常量，该类型成员可以直接在类中初始化，也可以在类中声明，在类定义体外进行定义。例如：上述程序中的x和xx变量。

对于5. 静态非整型常量，该类型也是可以在类中声明在类定义体外进行定义，或者直接在类中定义初始化。例如：上述程序中的z和zz变量。

结论：

静态成员属于类作用域，但不属于类对象，它的生命周期和普通的静态变量一样，程序运行时进行分配内存和初始化，程序结束时则被释放。所以不能在类的构造函数中进行初始化。

this指针

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

inline

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

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

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

虚函数（virtual）可以是内联函数（inline）吗？

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

volatile

volatile int i = 10;

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

C++ 中 struct 和 class

struct 更适合看成是一个数据结构的实现体，class 更适合看成是一个对象的实现体。

最本质的一个区别就是默认的访问控制

默认的继承访问权限。struct 是 public 的，class 是 private 的。
struct 作为数据结构的实现体，它默认的数据访问控制是public 的，而 class 作为对象的实现体，它默认的成员变量访问控制是 private 的。

union联合

联合（union）是一种节省空间的特殊的类，一个 union 可以有多个数据成员，但是在任意时刻只有一个数据成员可以有值。当某个成员被赋值后其他成员变为未定义状态。联合有如下特点：

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

#include<iostream>
union UnionTest {
	UnionTest() : i(10) {};
	int i;
	double d;
};
static union {
	int i;
	double d;
};
int main() {
	UnionTest u;
	union {
		int i;
		double d;
	};
	std::cout << u.i << std::endl; // 输出 UnionTest 联合的	10
	::i = 20;
	std::cout << ::i << std::endl; // 输出全局静态匿名联合的20
	i = 30;
	std::cout << i << std::endl; // 输出局部匿名联合的 30
	return 0;
}