目录
头文件（.h）和源文件（.cpp）两者的区别：
正常变量的声明与定义
//test.h
extern int b; //变量的声明//test.cpp
int b = 1;注意：变量不要在头文件中直接定义
正常函数的声明与定义
//test.h
void fun(int ); //声明//test.cpp
void fun(int a) {
cout << __FUNCTION__ << endl;
}类中的成员函数在对应的源文件中定义时，一定要加上类名作用域。
//test.h
class CTest{
public:
void fun();
};//test.cpp
void CTest::fun(){
cout << __FUNCTION__ << endl;
}类中普通成员属性和const成员属性在构造函数中的初始化参数列表进行初始化定义，而静态成员属性要在源文件中单独定义。
//test.h
class CTest {
public:
int m_a;
static int m_b;
const int m_c;
CTest(); //只声明
~CTest();
};//test.cpp
int CTest::m_b = 5;
//类成员函数在类外定义，需要在函数名前加上类名作用域
CTest::CTest():m_a(4) ,m_c(6){
cout << __FUNCTION__ << endl;
}
CTest::~CTest() {
cout << __FUNCTION__ << endl;
}常函数的声明与定义（保留const关键字）
//test.h
void funConst() const;
//test.cpp
//关键字需要保留
void CTest::funConst(/* const CTest* const this */) const {
cout << __FUNCTION__ << endl;
}静态成员函数的声明与定义（去掉static关键字）
//test.h
static void funStatic();//test.cpp
void CTest::funStatic() { //去掉static 关键字
cout << __FUNCTION__ << endl;
}虚函数的声明与定义（去掉virtual关键字）
//test.h
virtual void funVirtual();//test.cpp
//去掉 virtual关键字
void CTest::funVirtual() {
cout << __FUNCTION__ << endl;
}纯虚函数（不需要实现）
//test.h
virtual void fun() = 0;如果在一个头文件中创建一个类，然后另外两个头文件又都用到了这个头文件，在源文件中使用了另外两个头文件，那么第一个头文件中的类就会被创建两次，会出现重定义的错误。
//AA.h
class AA {
public:
int m_a = 0;
};//BB.h
#include"AA.h"
class BB {
public:
AA m_aa;
};//CC.h
#include"AA.h"
class CC {
public:
AA m_aa;
};在源文件中使用BB和CC两个头文件打开后就是这样：
class AA {
public:
int m_a = 0;
};
class BB {
public:
AA m_aa;
};
class AA {
public:
int m_a = 0;
};
class CC {
public:
AA m_aa;
};那么这种现象就称为头文件重复包含
解决头文件重复包含问题有两种方法：
对比：
将原文件（.cpp）初步处理，生成预处理文件（.i）：
将预处理后的文件（.i）进行一系列词法分析、语法分析、语义分析及优化，产生相应的汇编代码文件（.asm）。
将编译后的汇编代码文件（.asm）汇编指令逐条翻译成目标机器指令，并生成可重定位目标程序的.obj文件，该文件为二进制文件，字节编码是机器指令。
通过链接器将多个目标文件（.obj）和库文件链接在一起生成一个完整的可执行程序。
编译期：是指把源程序交给编译器编译、生成的过程，最终得到可执行文件。
运行期：是指将可执行文件交给操作系统执行、直到程序退出，把在磁盘中的程序二进制代码放到内存中执行起来，执行的目的是为了实现程序的功能。
#ifdef __cplusplus
#define A 1
#else
#define A 2
#endif
int a = A; //编译期确定
cout << a << endl; //1 int b = 0;
cin >> b;
if (b) {
b = 10;
}
else {
b = 20;
}
int c = b; //运行期确定
cout << c << endl; int len = 10;
int arr[len]; //编译期错误表达式的计算结果不是常数，编译期分配内存，因为必须要确定len的大小，但它是变量在编译期无法确定其具体值。
int len1 = 0;
cin >> len1;
int* p = new int[len1]; //运行期
//p[100] = 10; //数组越界:运行期错误程序崩溃：数组越界，在编译期是检查不出来的，在真正运行时可能会报错。
类：编译期的概念，包括：类成员函数、静态属性，作用域 访问修饰符
对象：运行期的概念实例，引用，指针
class CFather {
public:
virtual void fun() {
cout << "CFather::fun" << endl;
}
};
class CSon :public CFather {
private: //编译期的限制
virtual void fun() {
cout << "CSon::fun" << endl;
}
}; CFather* pFa = new CSon;
pFa->fun(); //Cson::fun编译器在检查代码时，他认为pFa->fun()调用的是父类中public属性的函数，那自然是通过编译的。但是在运行期时由于多态的作用，结果调用的是子类的fun函数，即使子类的fun函数是private但由于访问修饰符是编译期的限制，所以在运行时无效，子列的fun函数自然也能调用。
宏起到替换作用（预处理阶段），一般写法：
#define A 10一个标识符被宏定义后，在用到宏A的地方替换为10，再程序编译前预处理阶段进行替换，替换后才进行编译。
宏是可以传参数的，在宏名字后面加(PARAM)，参数的作用也是一个替换。
#define N(PARAM) int a = PARAM;一般情况下，宏替换当前这一行的内容，替换多行可以使用\这个字符
作用：用来连接当前行和下一行。
注意：一般最后一行不加\，\后面不能有任何字符，包括空格、tab、注释等。
#define B\
for (int i = 0; i < A; i++){\
cout << i << " ";\
}使用宏替换需要注意，宏及参数并不会像函数参数一样自动计算，也不做表达式求解，它只是单纯的复制粘贴。
#define N 2+3
int a = N*2; //2+3*2可以加上()来解决
#define N (2+3)
int a = N*2; //(2+3)*2#undef宏：取消宏定义，限制宏的作用范围
#define AB 10
cout << AB << endl;
#undef AB //取消宏定义
int AB = 20;
cout << AB << endl;优点
缺点
我们先来创建三个重载函数用以测试
void fun(int a) {
cout << __FUNCSIG__ << " " << a << endl;
}
void fun(const char* p) {
cout << __FUNCSIG__ << " " << p << endl;
}
void fun(char c) {
cout << __FUNCSIG__ << " " << c << endl;
}# 将宏参数转为字符串，相当于加了 双引号
#define D(PARAM) #PARAM
fun(D(123));
fun(D("abc"));
#@ 将宏参数转为字符，相当于加了 单引号
#define E(PARAM) #@PARAM
fun(E(1));
## 拼接作用，常用于宏参数与其他内容的拼接
#define F(PARAM) int a##PARAM = 100;
F(1)
cout << a1 << endl;内联函数是C++为了提高程序的运行速度做的一项改进，普通函数和内联函数主要区别不在于编写方式，而在于C++编译器如何将他们组合到程序中的。编译器将使用相应的函数代码替换到内联函数的调用处，所以程序无需跳转到另一个位置执行函数体代码，所以会比普通的函数稍快，代价是需要占用更多的内存，空间换时间的做法。
执行函数之前需要做一些准备工作i，要将实参、局部变量、返回地址以及若干寄存器都压入栈中，然后才能执行函数体中的代码，代码执行完毕后还要将之前压入栈中的数据都出栈。这个过程涉及到空间和时间的开销问题，如果函数体中的代码比较多，逻辑也比较复杂，那么执行函数体占用大部分时间，而函数调用、释放空间过程花费的时间占比很小可以忽略；如果函数体中的代码非常少，逻辑也非常简单，那么相比于函数体代码的执行时间，函数调用机制所花费的时间就不能忽略了。
int add(int a,int b){
return a+b;
}
int c = add(1,2);所以为了消除函数调用的时间开销，C++提供一种提高效率的方法：inline函数，上例中的add函数可以变为内联函数，如下，内联函数在编译时将函数调用处用函数体替换（类似于宏）。
inline int add(int a, int b) {
return a + b;
}
int c = add(1,2);注意：
class CTest{
void fun1(){} //默认内联
void fun2(); //声明
};
void CTest::fun2(){} //默认不是内联函数CTest tst;
tst.fun1(); //内联替换
tst.fun2(); //未替换void fun1(){
int a =10;
}
void fun2(){
int b= 20;
}
int main(){
fun1();
fun2();
return 0;
}汇编文件如下：
