C++学习 --函数

目录

1， 函数定义

1-1， 有返回值

1-2， 无返回值

2， 函数声明

3， 函数分文件编写

3-1， 创建自定义头文件

3-2， 创建源文件

3-3， 自定义头文件中编写函数声明

3-4， 在源文件中编写函数定义

3-5， 主文件添加自定义头文件

4， 默认参数

5， 占为参数

6， 函数重载

6-1， 参数个数不同重载

6-2， 参数类型不同重载

6-3， 参数顺序不同重载

6-4， 引用做函数重载

---

1， 函数定义

函数需要先定义， 再使用， 否则需要对函数进行声明后才能使用

1-1， 有返回值

通过数据类型 函数名(数据类型 参数){语句块 return 同函数数据类型}， 可定义一个有返回值函数

#include 
using namespace std;
 
//定义函数add
int add(int num1, int num2)
{
	int sum = num1 + num2;
 
	return sum;
}
 
int main()
{
	cout << add(100, 200) << endl;
 
	system("pause");
 
	return 0;
}

1-2， 无返回值

通过void 函数名(数据类型 参数){语句块}， 可定义一个无返回值函数

#include 
using namespace std;
 
//定义无返回值的函数，需要用void
void swap(int num1, int num2)
{
	int tmp = 0;
	
	cout << "交换前的数据：" << endl;
	cout << "num1 = " << num1 << endl;
	cout << "num2 = " << num2 << endl;
 
	tmp = num1;
	num1 = num2;
	num2 = tmp;
 
	cout << "交换前的数据：" << endl;
	cout << "num1 = " << num1 << endl;
	cout << "num2 = " << num2 << endl;
 
	//void类型的函数，不需要return 
}
 
int main()
{
	int num1 = 10;
	int num2 = 20;
 
	//调用swap函数
	swap(num1, num2);
 
	system("pause");
 
	return 0;
}

2， 函数声明

若调用函数在main函数后定义，则需要通过数据类型 函数名(数据类型 参数)的方式， 先对函数进行声明； 若在main函数前定义的函数，则不需要声明

#include 
using namespace std;
 
//对max_1进行声明
int max_1(int num1, int num2);
 
int main()
{
	int num1 = 10;
	int num2 = 20;
 
	//调用swap函数
	cout << "较大的值为：" << max_1(num1, num2) << endl;
 
	system("pause");
 
	return 0;
}
 
//max_1函数在main函数后，使用的时候需要声明
int max_1(int num1, int num2)
{
	return num1 > num2 ? num1 : num2;
}

3， 函数分文件编写

先在项目中创建一个头文件， 再创建一个源文件， 在自定义头文件中编写函数声明， 在源文件中编写函数定义， 在主文件中通过#include "自定义头文件"添加自定义头文件

下面以输出两个数字中较大值的函数举例

3-1， 创建自定义头文件

3-2， 创建源文件

3-3， 自定义头文件中编写函数声明

#include 
using namespace std;
 
int swap(int num1, int num2);

3-4， 在源文件中编写函数定义

//#include "swap.h"的作用：指定该文件使用的头文件为swap.h
#include "swap.h"
#include 
using namespace std;
 
//函数定义
int swap(int num1, int num2)
{
	return num1 > num2 ? num1 : num2;
}

3-5， 主文件添加自定义头文件

//添加头文件
#include "swap.h"
 
int main()
{
	int num1 = 10;
	int num2 = 20;
 
	//调用swap函数
	cout << "较大的值为：" << swap(num1, num2) << endl;
 
	system("pause");
 
	return 0;
}
-----------------------------------------------------------
输出结果：
较大的值为：20

4， 默认参数

通过数据类型 函数名(形参x=值x)的方式， 可以给函数定义默认参数

#include 
#include 
 
using namespace std;
 
//定义默认参数
int func(int a = 10, int b = 20)
{	
	return a + b;
}
 
int main()
{
	cout << func() << endl;
 
	system("pause");
 
	return 0;
}
------------------------------------------------
输出结果：
30

注意：

1， 若函数声明中定义了默认参数， 则函数定义中不能再次定义默认参数

int func(int a = 10, int b = 20);
//编译时会报错， 因为默认参数已经在声明中定义，不能再次定义
int func(int a = 10, int b = 20)
{	
	return a + b;
}

2， 从默认参数开始， 往后的参数都必须是默认参数

5， 占为参数

通过数据类型 函数名(数据类型1， 数据类型n=值)的方式， 可定义占为参数， 占位参数只写数据类型和值， 不用写参数名

#include 
#include 
 
using namespace std;
 
//下面定义了一个int类型的占为参数
void func(int a = 10, int=20)
{	
	cout << "调用了一个有占位参数的函数!!!" << endl;
}
 
int main()
{
	//注意：占位参数必须要显示传入
	func();
 
	system("pause");
 
	return 0;
}
------------------------------------------------------
输出结果：
调用了一个有占位参数的函数!!!

6， 函数重载

函数名称相同， 形参个数不同，名称不同， 顺序不同可以实现函数重载， 需要在同一个作用域

6-1， 参数个数不同重载

根据传入参数个数不同， 选择相应的函数进行调用

#include 
#include 
 
using namespace std;
 
void func()
{	
	cout << "调用func!!!" << endl;
}
 
void func(int a)
{
	cout << "func(int a)!!!" << endl;
}
 
int main()
{
	//因为传入了参数， 所以会调用func(int a)
	func(10);
 
	system("pause");
 
	return 0;
}
----------------------------------------------------
输出结果：
func(int a)!!!

6-2， 参数类型不同重载

根据传入参数类型不同， 选择相应的函数进行调用

#include 
#include 
 
using namespace std;
 
void func(int a)
{	
	cout << "调用func(int a)!!!" << endl;
}
 
void func(double b)
{
	cout << "func(int b)!!!" << endl;
}
 
int main()
{
	double b=20;
	//形参类型不同，进行函数重载
	func(b);
 
	system("pause");
 
	return 0;
}
-------------------------------------------
输出结果：
func(int b)!!!

6-3， 参数顺序不同重载

根据传入参数顺序不同(注意：参数需要不同的数据类型)， 选择相应的函数进行调用

#include 
#include 
 
using namespace std;
 
void func(int a, double b, int c)
{	
	cout << "调用int a, double b)!!!" << endl;
}
 
void func(double b, int a, int c)
{
	cout << "func(double a, int b)!!!" << endl;
}
 
int main()
{
	int a = 10;
	double b = 20;
	int c = 100;
	//参数顺序不同，进行函数重载
	func(b, a, c);
 
	system("pause");
 
	return 0;
}
---------------------------------------------
输出结果：
func(double a, int b)!!!

说明：函数的返回值不可以作为函数重载的条件

6-4， 引用做函数重载

const引用需要传入具体值才会调用， 普通引用直接传递变量

#include 
#include 
 
using namespace std;
 
//函数调用时， 只需传入变量
void func(int &a)
{	
	cout << "调用func(int &a)!!!" << endl;
}
 
//函数调用时， 需要传入具体的值，而不是变量
void func(const int &a)
{
	cout << "调用func(const int &a)!!!" << endl;
}
 
int main()
{
	int a = 10;
	const int& b = a;
	
	//这里会调用func(int &a)
	//因为调用func(int &a)时， 相当于int &a = a, 合法操作 
	func(a);
 
	cout << "-----------------------" << endl;
 
	//若这里会调用func(int &a)， 相当于int &a = 10， 不合法操作
	// 所以调用的是func(const int &a)
	func(10);
 
	system("pause");
 
	return 0;
}
-------------------------------------------------------------
输出结果：
调用func(int &a)!!!
-----------------------
调用func(const int &a)!!!