C++学习 --函数

qq_25500415

已于 2023-11-06 23:06:10 修改

阅读量157

点赞数

分类专栏： C++ 文章标签：学习

于 2023-11-02 23:22:07 首次发布

本文链接：https://blog.csdn.net/qq_25500415/article/details/134192675

版权

C++ 专栏收录该内容

25 篇文章 0 订阅

订阅专栏

1，函数定义

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

1-1，有返回值

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

#include <iostream>
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 <iostream>
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 <iostream>
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 <iostream>
using namespace std;

int swap(int num1, int num2);

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

//#include "swap.h"的作用：指定该文件使用的头文件为swap.h
#include "swap.h"
#include <iostream>
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 <iostream>
#include <string>

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 <iostream>
#include <string>

using namespace std;

//下面定义了一个int类型的占为参数
void func(int a = 10, int=20)
{	
	cout << "调用了一个有占位参数的函数!!!" << endl;
}

int main()
{
	//注意：占位参数必须要显示传入
	func();

	system("pause");

	return 0;
}
------------------------------------------------------
输出结果：
调用了一个有占位参数的函数!!!

6，函数重载

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

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

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

#include <iostream>
#include <string>

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 <iostream>
#include <string>

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 <iostream>
#include <string>

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 <iostream>
#include <string>

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)!!!