内联函数

宏：

宏的优缺点？
优点：
1.增强代码的复用性。
2.提高性能。
缺点：

1.展开后会使得代码长度变长，使可执行程序变大
2.不方便调试宏。（因为预编译阶段进行了替换）
3.导致代码可读性差，可维护性差，容易误用。（副作用）
4.没有类型安全的检查

先来回顾一下C语言中宏的知识点。

当一段代码被多次反复调用时，如果使用函数封装，将会重复地开辟、销毁多次函数栈帧，从而带来效率上较大的损耗。

为了提高效率，C语言中设计出了宏。宏是一种替换，会将这一段代码完全替换到要使用的地方，不用进行函数调用，从而提高了效率。

然而，宏由于替换的特点，需要格外注意“上下文”，是否需要加“括号”（操作符优先级问题），以及较差的可读性和不可调试的特点，只能适用于一些简单的场景。

总结：宏是用空间换时间，为了提高效率而产生的，但是在使用中又出现了一些其它的缺点。在C++中，产生了一种内联函数，可以专注于用空间换时间的效率提升。

Inline函数

升级点：

将短小且会多次调用的一段代码，仍然封装为一个函数，但是要在函数返回值前加上Inline。

在编译时，会将函数体展开（产生和宏一样的替换效果），从而提高效率。

这弥补了宏的2个缺点。

1、因为变成了一种函数，增加了类型检查，更加安全。

2、变成了函数形式，提高了可读性、可维护性，不容易出现歧义等“副作用”。

调试：

在debug下不可以调试，但可以修改编译器属性，使其可以调试。

在release版本下可以进行调试。

这样又解决了宏不可调试的缺点。

编译器优化：

inline对于编译器而言只是一个建议，不同编译器关于inline实现机制可能不同，一般建
议：将函数规模较小(即函数不是很长，具体没有准确的说法，取决于编译器内部实现)、不
是递归、且频繁调用的函数采用inline修饰，否则编译器会忽略inline特性。

简单来说：编译器会进行一个优化操作。

对于时间换空间，我们要在合理的范围内进行，比如牺牲5倍空间，换来2倍效率的提升是值得的，但是如果牺牲10000倍空间，就有些不值得了，不同编译器对于此尺度是不同的。如果内联函数过长，就会被直接忽略，不再展开，而是仍然进行函数调用call指令

举一个例子：如果inline函数仅有3行代码，并且被调用了1W次。转换成指令就变成了3W行。

若不使用inline函数，指令有（1W+3）行（1W次call，加上函数本身）这样的尺度是可以接受的。

如果inline函数有100行代码，指令为100W行。

不使用inline函数，指令仅有（1W+100）行，这样的话会使代码变得过长，编译器就会忽略了。

声明定义不分离：

由于inline函数的初衷是完成替换功能，而不是call指令，因此内联函数在翻译过程中是不会进行符号表，即不会参与后续的链接过程。

因此，当内联函数的定义与声明分离时，编译器就找不到要替换的部分了，就会产生错误。

必须要在哪个源文件使用，就在那里定义。

或者定义在头文件中，然后哪个源文件使用，就去包含头文件，即把函数的定义拷贝过去。

封装：

封装：将数据和操作数据的方法进行有机结合，隐藏对象的属性和实现细节，仅对外公开接口来
和对象进行交互。
我们可以定义一个类，并将这个类实例化为几个对象。

可以利用类中定义public的函数/方法对这些对象进行相关操作。

封装后，我们便不能在类的外面对于非公有变量进行操作。在C++中实现封装，可以通过类将数据以及操作数据的方法进行有机结合，通过访问权限来隐藏对象内部实现细节，控制哪些方法可以在类外部直接被使用。

this指针：

编译器实现原理：

我们先定义了一个Date的类，在C++中，成员函数都是定义在公共区域的，每次示例化的过程，开辟空间的只有成员变量（因为函数实现的功能是相同的，为了避免空间浪费）。

d1和d2调用的都是同一个Print函数，编译器底层是如何区分出d1和d2的呢？

在汇编中我们可以看到，编译器实际上将d1和d2的地址分别传给了Print函数，从而区分两个对象并且方便后续对不同对象内部进行相应操作。

但是在C++代码中，我们并没有传入&d1和&d2，编译器是如何实现的呢？

C++中通过引入this指针解决该问题，即：C++编译器给每个“非静态的成员函数“增加了一个隐藏
的指针参数，让该指针指向当前对象(函数运行时调用该函数的对象)，在函数体中所有“成员变量”
的操作，都是通过该指针去访问。只不过所有的操作对用户是透明的，即用户不需要来传递，编
译器自动完成。

简单来说，编译器内部使得每一个成员函数都多了一个 DataType * const this 类型的指针，可以接收不同对象的不同地址，const的修饰使得this只能指向外部指定的这个对象。

这个this指针是隐式传递的，不可以显式传递和接收。

在成员函数内部可以使用this指针。

this指针特性

1. this指针的类型：类类型* const，即成员函数中，不能给this指针赋值。
2. 只能在“成员函数”的内部使用
3. this指针本质上是“成员函数”的形参，当对象调用成员函数时，将对象地址作为实参传递给
this形参。所以对象中不存储this指针。
4. this指针是“成员函数”第一个隐含的指针形参，一般情况由编译器通过ecx寄存器自动传
递，不需要用户传递
因为this指针是形参，所以它存在栈区。

this指针能否为空？

首先我们要知道，对空指针解引用是一种运行错误，而不是编译错误。

先是定义了一个A类的指针p，且p为空指针。

C++代码上，p->Print()看似是对p进行解引用，但因为成员函数都放在公共区域，并不需要对象的指针p去寻找，即底层上并没有对p进行解引用，只是将p（对象的地址）传入Print函数中，并用this指针这个形参进行接收。

然后要看在成员函数内部是否对this空指针进行解引用。

情况1中没有，因此可以正常运行。情况2中解引用了，产生执行错误。

因此，this指针可以接收为空，只要不解引用即可。

构造函数：

在C语言中，我们有时可能会忘记进行初始化和销毁，在C++中，构造函数和析构函数可以进行编译器自动初始化和销毁。

在空类中编译器会生成6个默认成员函数。

默认成员函数：用户没有显式实现，编译器会生成的成员函数称为默认成员函数。

构造函数是一个特殊的成员函数，名字与类名相同,实例化对象时由编译器自动调用，以保证
每个数据成员都有一个合适的初始值，并且在对象整个生命周期内只调用一次。构造函数是特殊的成员函数，需要注意的是，构造函数虽然名称叫构造，但是构造函数的主要任务并不是开空间创建对象，而是初始化对象。

特性：

1. 函数名与类名相同。
2. 无返回值。
3. 对象实例化时编译器自动调用对应的构造函数。
4. 构造函数可以重载
5. 如果类中没有显式定义构造函数，则C++编译器会自动生成一个无参的默认构造函数，一旦
用户显式定义编译器将不再生成

6.对内置类型成员不初始化，自定义成员初始化。
注：C++11 中针对内置类型成员不初始化的缺陷，又打了补丁，即：内置类型成员变量在
类中声明时可以给默认值。

7. 无参的构造函数和全缺省的构造函数都称为默认构造函数，并且默认构造函数只能有一个。
注意：无参构造函数、全缺省构造函数、我们没写编译器默认生成的构造函数，都可以认为
是默认构造函数。

typedef int DataType;
class Stack
{
public:
	//  3、对象示例化时自动调用构造函数  1、同类名  2、无返回值  4、可以重载
	Stack(DataType capacity = 3)
	{
		cout << "Stack(DataType capacity = 3)" << endl;
		_array = (DataType*)malloc(sizeof(DataType) * capacity);
		if (NULL == _array)
		{
			perror("malloc申请空间失败!!!");
			return;
		}
		_capacity = capacity;
		_size = 0;
	}
	//  构造函数支持重载的另一种初始化方式
	Stack(DataType* a, int n)
	{
		_array = (DataType*)malloc(sizeof(DataType) * n);
		if (nullptr == _array)
		{
			perror("malloc fail");
			return;
		}

		memmove(_array, a, sizeof(DataType) * n);
		_capacity = n;
		_size = n;
	}

	void Push(DataType data)
	{
		// CheckCapacity();
		_array[_size] = data;
		_size++;
	}

	~Stack()
	{
		cout << "~Stack()" << endl;
		if (_array)
		{
			free(_array);
			_array = NULL;
			_capacity = 0;
			_size = 0;
		}
	}
private:
	DataType* _array;
	int _capacity;
	int _size;
};