十八、函数(一)

十八、函数(一)

1、函数概述

1)函数带来的好处

①代码模块化,便于阅读维护

②代码模块化以后,能够实现分工合作

③减少重复代码,降低工作流

2)函数的语法

//函数的语法
返回类型 函数名称(参数,参数,参数,参数)  //参数的语法包括:参数类型 参数名称
{
    函数的功能区;
    return 返回值;
}

//函数的声明示范一
int Add(int a,int b)
{
    return a+b;
}
使用:
int a=Add(100,200);   //a=300

//函数的声明示范二
void PrintLog(char *str)
{
    std::cout<<"日志:"<<str;
}
使用:
Printlog("你好世界!");
//函数的声明示例
// 函数一.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
//

#include <iostream>

int Add(int a, int b)   //函数的声明
{
    return a + b;       ////返回的是什么类型的值,就用什么类型接受
}
//不需要返回值的函数,使用的返回类型为void
void PrintEnding(const char* str,int x)
{
    std::cout << str << x << std::endl;
}

int main()
{
   int x{ Add(100, 100) };  //函数的使用
   PrintEnding("生命值:",x);
   x =Add(200,300);
   PrintEnding("内力值:",x);
}

注:每个函数都必须有return函数返回值,main()函数编译器会自动在函数结尾默认加一个return

//用函数实现游戏麟江湖排行榜设计修
//GetDataCount函数统计有几个角色的信息
int GetDataCount(string str)
{
	int icount{};
	for (int i = 0; i < str.length(); i++)
	{
		if (str[i] == ';')
		{
			icount++;
			i += 3;
		}
	}
	return icount/2;
}

//获取字符串中的数据
string GetDataStr(string str, int istart)
{
	string strReturn{};
	int iend{};
	istart = str.find("id=", istart);
	if (istart == std::string::npos) return strReturn;
	iend = str.find(";", istart + 3);
	strReturn = str.substr(istart + 3, iend - istart - 3);
	return strReturn;
	
}
2、函数参数之指针参数

函数分为三部分:包括函数的头部、函数体、函数的尾部(一个函数有可能有很多尾部)、

函数头中的变量只申请了内存空间、但是没有赋值,没有初始化

函数尾是为了返回值

//直接将实参传递给形参
#include <iostream>

int Add(int x, int y)  //形参
{
	x *= 100;
	y *= 100;
	return x + y;
}

int main()
{
	int x = 2, y = 1;
	int c = Add(x,y);  //实参
	std::cout << "c=" << c << "   x=" << x << "   y=" << y << std::endl;
}
//通过此种方式无法得到x和y变化后的结果

//向函数中传入指针参数(将函数中的值读取去出来,获得回传值)
#include <iostream>

int Add(int* x, int* y)  //形参
{
	(*x) *= 100;       //x和y次数是一个指针
	(*y) *= 100;
	return (*x) + (*y);
}

int main()
{
	int x = 2, y = 1;
	int c = Add(&x, &y);  //实参传入x和y的内存地址
	std::cout << "c=" << c << "   x=" << x << "   y=" << y << std::endl;
}
//通过结果发现c的值没有发生变化,但是x和y的值发生了变化。成为函数中最终计算的x和y的结果

2)指针参数的常见应用

​ 函数头部中的形参在定义时,会分配整个结构体内部成员变量总和的内存空间,会存在内存空间开销过剩的问题;但是如果函数头部中传入的参数为指针参数,那么只需要分配指针大小的函数空间,即4字节.

//不使用指针参数,给函数传值
#include <iostream>

struct Role
{
	int Hp;
	int Mp;
};

int Exp(Role role)
{
	return role.Hp + role.Mp;
}

int main()
{
	Role role{ 500,1000 };
	int totle =Exp(role);  //看起来函数在调用时传入了一个参数,但是实际上传入了两个参数
	std::cout << "角色战斗力为:" << totle << std::endl;
}

//通过指针参数,给函数传值
#include <iostream>

struct Role
{
	int Hp;
	int Mp;
};

int Exp(Role* role)
{
	return role->Hp + role->Mp;     //不再使用.取实体,而是通过->偏移符号通过地址传值
}

int main()
{
	Role role{ 500,1000 };
	int totle = Exp(&role);  //取地址
	std::cout << "角色战斗力为:" << totle << std::endl;
}
//通过此方式可大大提升效率

3)指针参数之常量指针用法

回顾:常量指针,表示指针指向的内容是一个常量,指针指向的内容不可以发生变化,即值可以读,但不可以写,防止修改数据

//初始化一个玩家和怪物,定义一个函数,返回一个bool值,当值为true的时候,说明角色死亡
#include <iostream>

struct Role
{
	int Hp;
	int Mp;
	int damage;
};

bool Exp(const Role* Acter, Role* beActer)  //攻击者者和被攻击者,攻击者的属性不能够修改
{
	beActer->Hp -= Acter->damage;  //被攻击者血量=被攻击者血量-攻击者伤害值
	return beActer->Hp <= 0;
}

int main()
{
	Role user{ 500,1000,1200 };
	Role monster{ 1500,1000,1000 };

	if (Exp(&monster, &user)) 
			std::cout << "角色死亡!" << std::endl;
	else 
		if (Exp(&user ,&monster))
			std::cout << "怪物死亡" << std::endl;
}
3、函数参数之数组参数

1)数组本质上就是一个指针,传入数组参数时,要传入数组的长度。提高如下两种数组参数的定义方法

//传入数组参数时,必须要传入数组的长度
//数组参数方法一
Void Sort(int ary[],unsigned count)   //推荐
{
    for(int i=1;i<count;i++)
}
int main()
{
    int a[5]{ 2302,5212,3653,9480,5200 };
	Sort(a, 5);
}

//数组参数方法一
Void Sort(int* ary,unsigned count)   //推荐
{
    for(int i=1;i<count;i++)
}
int main()
{
    int a[5]{ 2302,5212,3653,9480,5200 };
	Sort(a, 5);
}
//将数组进行排序案例
#include <iostream>

void Sort(int ary[],unsigned count)   
{
		for (int i = 1; i < count; i++)
		{
			if (ary[i] > ary[i - 1])
			{
				int tmp = ary[i];
				ary[i] = ary[i - 1];
				ary[i - 1] = tmp;
			}
		}
}

int main()
{
	int a[5]{ 2302,5212,3653,9480,5200 };
	Sort(a, 5);
	for (auto x : a)std::cout << x << std::endl;
}

2)多维数组的传参

//多维数组的传参,无法写成指针的形式
Void Sort(int ary[][2],unsigned count)   //推荐
{
    f
}
int main()
{
    int a[3][2]{{1,2},{3,4},{5,6}};
	Sort(a, 3);  //传入数组的长度
}
4、函数参数之引用参数
//引用回顾
int a=5;
int &b = a;      //引用就相当于被阉割了的指针
则b++就相当于a++

1)引用也可以使用const进行限定只能读,不能写

#include <iostream>

struct Role
{
	int Hp;
	int Mp;
	int damage;
};

bool Exp(const Role& Acter, Role& beActer)  //引用,相当于Role& Acter = user;Role& beActer=monster
{
	beActer.Hp -= Acter.damage;  
	return beActer.Hp <= 0;
}

int main()
{
	Role user{ 5000,1000,12000 };
	Role monster{ 1500,1000,1000 };
	if (Exp(user, monster))std::cout << "怪物死亡,获得经验值XXX" << std::endl;
}

2)引用和指针的区别

引用要想使用,必须先得初始化;而指针可以先传入一个空指针,先不进行初始化

//此种方式错误,引用必须初始化
bool Act(Role& Acter,Role& beAct)
{
    return true;
}
Act(nullptr,nullptr);

//指针可以不进行初始化
bool Act(Role* Acter,Role* beAct)
{
    return true;
}
Act(nullptr,nullptr);

3)指针类型的引用

//指针类型的引用
#include <iostream>

struct Role
{
	char name[0x20];
	int Hp;
	int Mp;
	int damage;
};

bool Exp(const Role& Acter, Role*& beActer)  //Role*指针类型的引用
{
	beActer->Hp -= Acter.damage;
	bool End = beActer->Hp < 0;
	beActer = (Role*)&Acter;  //通过指针类型的引用,可以修改参数的指向,此处将被攻击者修改为攻击者
	return End;
}

int main()
{
	Role user{ "奥特曼",5000,1000,12000 };
	Role monster{ "小怪兽",1500,1000,1000 };
	Role* pRole = &monster;
	if (Exp(user, pRole))std::cout << pRole->name<<"     怪物死亡,获得经验值XXX" << std::endl;
}

可以使用如下写法

//指针类型的引用的其他写法
#include <iostream>

typedef struct Role
{
	char name[0x20];
	int Hp;
	int Mp;
	int damage;
}*PROLE;     //Role类型的指针PROLE  

bool Exp(const Role& Acter, PROLE& beActer)  //Role类型指针PROLE的引用
{
	beActer->Hp -= Acter.damage;
	bool End = beActer->Hp < 0;
	beActer = (Role*)&Acter;  //通过指针类型的引用,可以修改参数的指向,此处将被攻击者修改为攻击者
	return End;
}

int main()
{
	Role user{ "奥特曼",5000,1000,12000 };
	Role monster{ "小怪兽",1500,1000,1000 };
	PROLE pRole = &monster;  ////Role类型指针PROLE
	if (Exp(user, pRole))std::cout << pRole->name<<"     怪物死亡,获得经验值XXX" << std::endl;
}
5、函数参数之默认实参

1)默认参数引入

//传入一组数,对其进行排序
#include <iostream>

void Swap(int &a,int &b)  //定义函数专门用来交换两个数
{
	int tmp = a;
	a = b;
	b = tmp;
}

void Sort(int ary[], unsigned count,bool BigSort)  //定义函数用来排序
{
	for(int i=1;i<count;i++)
	{ 
		bool bcase = BigSort ? ary[i] > ary[i - 1]:ary[i - 1] > ary[i];
		if (bcase)Swap(ary[i], ary[i - 1]);
	}
}

int main()
{
	int a[5]{ 2302,5212,3653,9480,5200 };
	Sort(a, 5,false);  //true表示从大到小排序,false表示从小到大排序
	for (auto x : a)std::cout << x << std::endl;
}

2)默认参数使用

​ 在函数调用时,若不传递值,则使用函数声明时设置的默认参数。默认参数只可以放置在最后,不可以放置在最前面或中间;若有多个默认参数,需要依次写在最后面

//默认参数使用
#include <iostream>

void Swap(int &a,int &b)
{
	int tmp = a;
	a = b;
	b = tmp;
}

void Sort(int ary[], unsigned count,bool BigSort=true)  //定义函数默认值参数
{
	for(int i=1;i<count;i++)
	{ 
		bool bcase = BigSort ? ary[i] > ary[i - 1]:ary[i - 1] > ary[i];
		if (bcase)Swap(ary[i], ary[i - 1]);
	}
}

int main()
{
	int a[5]{ 2302,5212,3653,9480,5200 };
	Sort(a, 5); //函数调用时,若不传入参数,默认使用函数声明时形参的默认值
	for (auto x : a)std::cout << x << std::endl;
}

热门相关:大胸儿媳妇   演播室   家庭主妇经销商   亲切的嫂子   傲娇驾到,总裁别闹