【c++】动态内存分配 ｜ 内联函数和函数重载 ｜函数的缺省参数

用new运算符实现动态内存分配

需要多少空间就分配多少

第一种方法，分配一个变量：P = new T

p是类型为T *的指针，T是任意类型名。
动态分配出一片大小为sizeof(T)字节的内存空间，并且将该内存空间的起始地址赋值给P

int *pn;
pn = new int;
*pn = 5;//往新分配出来的存储空间里写了个5

第二种方法，分配一个数组：P = new T[N]

p是类型为T 的指针，T是任意类型名，N要分配的数组元素个数，可以是整型表达式。
动态分配出一片大小为Nsizeof(T)字节的内存空间，并且将该内存空间的起始地址赋值给P

int *pn;
int i = 5;
pn = new int[i * 20];
pn[0] = 20;
pn[100] = 30;//编译没问题，运行时导致数组越界（最大下标99

new T; new T[n];
这两个表达式返回值的类型都是T*
int *p = new int;

用new动态分配的内存空间，一定要用delete运算符进行释放。如果不进行释放，最后可能会导致操作系统或者别的应用程序运行空间不够，系统会越来越慢甚至崩溃。

delete指针;  //该指针必须指向new出来的空间。

int *pn = new int;
*pn = 5;
delete p;
delete p;//导致异常，一片空间不能被delete两次

delete释放动态分配的数组，要加[]

delete[] 指针；//该指针必须指向new出来的数组

int *pn = new int[20];
pn[0] = 5;
delete[]p;

内联函数

函数调用是有时间开销的，如果函数本身只有几条语句，执行非常快，而且函数被反复执行很多次，相比之下调用函数所产生的这个开销就会显得比较大。
为了减少函数调用的开销，引入了内联函数机制。编译器处理对内联函数的调用语句时，是将整个函数的代码插入到调用语句处，而不会产生调用函数的语句。
在函数定义前面加“inline”关键字，即可定义

inline int Max(int a, int b)
{
	if(a > b)return a;
	return b;
}

k = Max(n1, n2)
//相当于
if(n1 > n2)
	tmp = n1;
else tmp = n2;
k = tmp;

函数重载

一个或者多个函数，名字相同，然而参数个数或者参数类型不相同，这就叫函数的重载。
以下三个函数是重载关系：

int Max(double f1, double f2){}
int Max(int n1, int n2){}
int Max(int n1, int n2, int n3){}

函数重载使得函数命名变得简单。
编译器根据调用语句的中的实参的个数和类型判断应该调用哪个函数。

Max(3.4, 2.5)//调用1
Max(2, 3)//调用2
Max(2, 3, 4)//调用3
Max(3, 2.4)//error,二意性

如果参数类型和个数都一样，只是返回的类型不一样，这不叫函数重载，叫函数的重复定义。

函数的缺省参数

c++中，定义函数的时候可以让最右边的连续若干个参数有缺省值，那么调用函数的时候，若相应位置不写参数，参数就是缺省值。

void func(int x1, int x2 = 2, int x3 = 3){}
func(10);//等效于func(10, 2, 3)
func(10, 8);//等效于func(10, 8, 3)
func(10, , 8);//不行，只能最右边的连续若干个参数缺省

参数可缺省的目的在于提高程序的可扩充性。
如果某个写好的函数要添加新的参数，而原先的调用该函数的语句，位必须要用新增的参数，那么为了避免对原先那些函数调用语句的修改，就可以使用缺省参数。