函数的特性

内联函数

内联函数在编译时，被嵌入到主调函数中。

一般只有简单且频繁调用的函数才能成为内联函数。

// 定义内联函数
inline int f(int a, int b);

int main()
{
	for (int i = 0; i < 10000; i++)
	{
		//cout << f(10, i) << ", ";
		cout << 10 + i << ", ";
	}
	cout << endl;
	return 0;
}

int f(int a, int b)
{
	return a + b;
}

函数重载

在C++中可以定义多个同名函数，只要它们的形参的个数或类型不完全相同就可以，这些同名函数称为重载函数。

程序根据实参与形参的类型及个数自动确定调用哪一个同名函数。

//	定义重载函数myMax
int myMax(int a, int b);

float myMax(float a, float b);

int main()
{
	int i1 = 1, i2 = 0;
	float f1 = 1.0, f2 = 2.0;
	//	根据参数确定调用哪个重载函数
	myMax(1, 0);
	myMax(1.0f, 0.0f);

	return 0;
}

int myMax(int a, int b)
{
	cout << "int max(int a, int b)" << endl;
	if (a > b)
	{
		return a;
	}
	return b;
}

float myMax(float a, float b)
{
	cout << "float max(float a, float b)" << endl;
	if (a > b)
	{
		return a;
	}
	return b;
}

带默认值的函数

函数声明或定义时，可以预先为函数参数指定默认值。

函数调用时，如果给出实参则使用实参，否则使用形参的默认值。

形参默认值必须由右向左顺序定义，否则编译时会产生错误。

//	默认值可以在函数声明时给出
float power(float m , int n = 2);
/*
	形参默认值必须由右向左顺序定义，否则编译时会产生错误
	f(int a, int b, int c = 10); 正确
	f(int a, int b= 10, int c = 10); 正确
	f(int a, int b= 10, int c ); 错误
	f(int a =10, int b= 10, int c ); 错误
	f(int a =10, int b, int c ); 错误
*/
int main()
{
	//	在函数调用时，如果给出实参则使用实参，否则使用形参的默认值
	cout << power(2) << endl;
	cout << power(2, 3) << endl;
	return 0;
}

float power(float m, int n)
{
	float r = 1.0;
	for (int i = 0; i < n; i++)
	{
		r *= m;
	}
	return r;
}

函数指针

函数所占用内存的起始值地址就是函数的地址，用于保存函数地址的指针变量称为函数指针变量。

函数指针变量用于调用函数。

int myAdd(int x, int y);
int myMinus(int x, int y);

int main()
{
	int a = 20;

	//	定义函数指针,用于指向具有两个int型参数，并且返回int型参数的函数。
	int (*fp)(int, int);

	//	使用函数指针调用myAdd函数
	fp = myAdd;
	a = fp(10, 10);
	cout << "a: " << a << endl;

	//	使用函数指针调用myMinus函数
	fp = myMinus;
	a = fp(10, 10);
	cout << "a: " << a << endl;

	return 0;
}

int myAdd(int x, int y)
{
	return x + y;
}
int myMinus(int x, int y)
{
	return x - y;
}

函数的嵌套调用与递归调用

函数的嵌套调用

嵌套调用指被调函数中又调用了其他函数。

//	多个阶乘求和。例如n个阶乘求和， 0! + 1! + 2! + 3! ... + n!

//	多个阶乘的结果求和
int f1(int n);

//	计算m的阶乘
int f2(int m);

int main()
{	
	cout << f1(3) << endl;
	return 0;
}

int f1(int n)
{
	int sum = 0;
	for (int i = 0; i <= n; i++)
	{
		sum += f2(i);
	}
	return sum;
}

int f2(int m)
{
	int r = 1;
	for (int i = 1; i <= m; i++)
	{
		r *= i;
	}	
	return r;
}

递归调用

函数直接或间接调用它本身，称为递归调用。这种函数叫做递归函数。

//	递归求阶乘
int myPower(int n);

int main()
{
	cout << myPower(0) << endl;
	cout << myPower(3) << endl;
	cout << myPower(30) << endl;
	return 0;
}

int myPower(int n)
{
	int r;
	if (n > 1)
	{
		r = n * myPower(n - 1);
	}
	else 
	{
		r = 1;
	}
	return r;
}