（九十六）函数和结构-CSDN博客

结构比字符串／数组简单之处在于，可以把一个结构赋给另一个结构，而字符串、数组不行。

注：例如 struct abc{int a; int b;}这样的结构定义，其中abc为类型名。可以称之为abc结构。

函数可以直接返回结构，

但若需要地址的话，需要加上地址运算符&才能得到结构的地址。

返回结构的函数头为：

类型名函数名(传递的参数)

如代码：

#include<iostream>
using namespace std;

struct ab	//定义ab结构
{
	int a;	//ab的两个变量
	int b;
};
ab abc(void);	//ab结构的函数原型，这个结构函数无传递参数

int main()
{
	ab c;	//声明ab结构c，c为使用ab结构的变量名。
	c = abc();	//调用结构函数abc，将返回值赋值给变量c
	cout << c.a << endl;	//打印c的变量a的值
	cout << c.b << endl;	//打印c的变量b的值
	cout << &c << endl;	//打印c的地址
	system("pause");
	return 0;
}

ab abc(void)	//ab结构的函数头，函数名为abc
{
	ab def = { 3,5 };	//初始化def，使用ab结构，赋值分别为3和5
	return ab(def);	//返回def，格式为 定义结构(使用该结构的变量名)，或 直接输入def，省略ab和括号也可以
}

输出：

3
5
002FF7C0
请按任意键继续. . .

总结：

①函数头：

格式为：定义的结构（如代码中的ab）函数名(参数);

不同的结构使用不同的定义的结构。

②参数：

可以无参数，也可以按实际需要传递参数。

结构名（如代码中的c）可以直接当参数进行传递，例如以上代码若要传递参数的话，改为：

ab abc(ab,ab) 注：ab是定义的结构

③返回值：

格式为：return 使用该结构的变量名; 或 return 定义的结构(使用该结构的变量名)

如代码中的：return def; 或 return ab(def);

二者是等价的。

结构名作为返回值的时候，返回的是这个结构所包含的所有成员变量。

④结构在函数中的使用方式：

像使用单体变量那样使用函数，如函数名.变量名这样。

只不过结构名作为参数的时候，导入的是这个结构变量的所有成员。

以下是以结构作为参数进行传递的代码：

#include<iostream>
#include<string>
#include<ctime>
#include<Windows.h>
using namespace std;

struct shuxing	//shuxing是类型名
{
	string name;
	int str;
};

shuxing heti(shuxing, shuxing);

int main()
{
	cout << "你和你的伙伴遇见一个强大的boss，现在你们需要合体来战胜他！" << endl;
	cout << "请输入你的姓名：";
	shuxing player_1;	//声明使用shuxing的结构player_1
	getline(cin, player_1.name);	//读取一整行，避免因为空格而导致读取的名字不完全
	cout << "系统正在测试你的体格";
	for (int i = 0;i < 5;i++)	//等待0.5*5秒
	{
		cout << ".";
		Sleep(500);
	}
	cout << endl;
	player_1.str = clock() % 100;	//随机一个属性，利用求余，范围为0~99
	cout << "你的体格为：" << player_1.str << endl;
	cout << "————————————" << endl;
	cout << "请输入你的伙伴的姓名：";
	shuxing player_2;
	getline(cin, player_2.name);
	cout << "系统正在测试你的伙伴的体格";
	for (int i = 0;i < 5;i++)
	{
		cout << ".";
		Sleep(500);
	}
	cout << endl;
	player_2.str = clock() % 100;
	cout << "你的伙伴的体格为：" << player_2.str << endl;
	cout << "现在你们俩进行合体ing";
	for (int i = 0;i < 5;i++)
	{
		cout << ".";
		Sleep(500);
	}
	shuxing bigger = heti(player_1, player_2);	//结构bigger为函数调用2个参数后的返回值
	cout << "你们已经合体完毕！\n合体后的名字为：" << bigger.name << endl;
	cout << "合体后的体格为：" << bigger.str << endl;
	cout << "请点击任意键与boss战斗" << endl;
	cin.sync();	//清除输入缓存
	cin.get();	//从而利用读取任意输入来达成等待的目的
	cout << "战斗完毕，你们胜利了！\n游戏结束" << endl;
	system("pause");
	return 0;
}

shuxing heti(shuxing player_1, shuxing player_2)
{
	shuxing sum;	//声明结构sum，计划为两个结构的之和
	sum.str = player_1.str + player_2.str;
	sum.name = player_1.name + "*" + player_2.name;
	return sum;
}

输出：

你和你的伙伴遇见一个强大的boss，现在你们需要合体来战胜他！
请输入你的姓名：wd
系统正在测试你的体格.....
你的体格为：43
————————————
请输入你的伙伴的姓名：dw
系统正在测试你的伙伴的体格.....
你的伙伴的体格为：8
现在你们俩进行合体ing.....你们已经合体完毕！
合体后的名字为：wd*dw
合体后的体格为：51
请点击任意键与boss战斗

战斗完毕，你们胜利了！
游戏结束
请按任意键继续. . .

总结：

①string类型可以直接相加；

②可以把返回结构的函数，直接赋值给一个已被初始化的结构——因为结构可以赋给另外一个结构（只要他们使用同一个定义的结构）；

如把：shuxing bigger = heti(player_1, player_2);

改成：player_1 = heti(player_1, player_2);

坐标、角度、弧度之间互相转换的代码：

#include<iostream>
#include<cmath>	//数学库，sqrt()是开方，atan2(y,x)可以求坐标x,y和原地之间的弧度值。
#include<Windows.h>

using namespace std;
struct rect	//坐标的结构，使用横坐标x和纵坐标y
{
	double x;
	double y;
};

struct jiaodu
{
	double distance;
	double jiao;
};

struct polar //使用弧度的结构，内容分别为弧度、点距离原点的距离
{
	double distance;	//距离
	double angle;	//弧度
};

rect polar_to_rect(polar);	//弧度转坐标
rect jiaodu_to_rect(jiaodu);	//角度转坐标
polar jiao_to_polar(jiaodu m);	//角度转弧度
jiaodu rect_to_jiaodu(rect);	//坐标转角度

int main()
{
	cout << "这里可以在坐标、角度、弧度之间任意转换和输出转换后的结果。" << endl;
	cout << "请输入你要输入的内容：\n1.坐标\n2.角度和距离\n3.弧度和距离。" << endl;
	char choice;
	cin >> choice;
	rect x_y;	//结构，坐标相关
	polar d_a;	//结构，弧度相关
	jiaodu d_j;	//结构，角度相关
	while (choice!='1'&&choice!='2'&&choice!='3')
	{
		cout << "输入错误，请重新输入：";
		cin.sync();
		cin >> choice;
	}
	switch (choice)
	{
	case'1':cout << "请输入x坐标：";
		cin >> x_y.x;
		cout << "请输入y坐标：";
		cin >> x_y.y;	//获得坐标
		break;
	case'2':cout << "请输入角度（单位：°）：";
		cin >> d_j.jiao;
		cout << "请输入距离：";
		cin >> d_j.distance;
		x_y = jiaodu_to_rect(d_j);	//将输入的内容转为坐标
		break;
	case'3':cout << "请输入弧度（单位：rad）：";
		cin >> d_a.angle;
		cout << "请输入距离：";
		cin >> d_a.distance;
		x_y = polar_to_rect(d_a);	//将输入的内容转为坐标
		break;
	}
	cout << "计算ing";
	d_j = rect_to_jiaodu(x_y);	//调用函数，将坐标转为角度
	d_a = jiao_to_polar(d_j);	//将角度转为弧度
	for (int i = 0;i < 5;i++)
	{
		cout << ".";
		Sleep(200);
	}
	cin.sync();	//清除输入缓存
	cout << "请选择你想要显示的结果：" << endl;
	cout << "1.全部\n2.x，y坐标\n3.角度和距离\n4.弧度和距离\n-->> ";
	char choice_2;
	cin >> choice_2;
	while (cin)
	{
		switch (choice_2)
		{
		case'1':
		case'2':cout << "x坐标为：" << x_y.x << "  y坐标为：" << x_y.y << endl;
			if (choice_2 != '1')break;
		case'3':cout << "距离为：" << d_j.distance << "  角度为：" << d_j.jiao << "°" << endl;
			if (choice_2 != '1')break;
		case'4':cout << "距离为：" << d_a.distance << "  弧度为：" << d_a.angle << " rad  " << endl;
		default:if (choice_2 == '1')break;cout << "输入错误，请重新输入：";cin >> choice_2;continue;
		}
		break;	//若无意外，则离开循环
	}
	system("pause");
	return 0;
}

rect polar_to_rect(polar p)	//弧度转坐标
{
	rect dian;
	//sin角度=对边/斜边。
	dian.y = sin(p.angle)*p.distance;	//对边(y) = sin角度*斜边。
	dian.x = cos(p.angle)*p.distance;	//临边(x) = sin角度*斜边
	return dian;
}
rect jiaodu_to_rect(jiaodu p)	//角度转坐标
{
	rect dian;
	const double jiao_to_angle = 57.29577951;	//角度/弧度的值大概是这个数
	double hudu = p.jiao/jiao_to_angle;	//角度除以这个值得到弧度
	dian.y = sin(hudu)*p.distance;	//对边(y) = sin弧度*斜边。
	dian.x = cos(hudu)*p.distance;	//临边(x) = sin弧度*斜边
	return dian;
}
polar jiao_to_polar(jiaodu m)	//角度转弧度
{
	polar dian;
	dian.distance = m.distance;	//距离是一样的
	const double jiao_to_angle = 57.29577951;	//角度/弧度的值大概是这个数
	dian.angle = m.jiao / jiao_to_angle;	//角度除以这个数=弧度值
	return dian;		//返回polar结构（弧度）
}
jiaodu rect_to_jiaodu(rect m)	//坐标转角度
{
	jiaodu dian;
	const double jiao_to_angle = 57.29577951;	//角度/弧度的值大概是这个数
	dian.distance = sqrt(m.x*m.x + m.y*m.y);	//利用坐标求距离
	dian.jiao = atan2(m.y, m.x)*jiao_to_angle;	//利用坐标求角度
	return dian;	//返回jiaodu结构（角度）
}

以上函数可以自由选择输入哪个类型的数据，然后决定输出哪个类型的结果（或者输出全部结果）。

注意：

①计算时使用的是弧度，而不是角度；

②由于码代码时没有理解，所以最后两个函数并非最优化。

应该为坐标转弧度的函数优先，然后再弧度转角度。

而非是代码中的坐标转角度、在角度转弧度。

结构指针、函数：

函数也可以将结构指针作为参数，或者返回值。

作为参数时的格式：void 函数名(结构类型*变量名)

作为返回值时：结构类型*函数名(传递的参数)

如代码：

#include<iostream>
#include<string>
using namespace std;

struct shuxing	//结构，属性
{
	string name;
	int str;
	int def;
	int hp;
	int mp;
	int luck;
	int gold;
};
shuxing*wanjia(void);	//返回值是结构地址（指针）
void combat(shuxing*);	//导入数据为指针，无返回值

int main()
{
	shuxing *player_1=wanjia();	//让玩家输入自己的属性
	cout << "现在开始计算你的战斗力..." << endl << endl;
	combat(player_1);	//计算战斗力，并输出
	system("pause");
	return 0;
}

shuxing*wanjia(void)	//返回结构指针，无传递的参数
{
	shuxing *player = new shuxing;
	cout << "这里是战斗力计算器，请输入你的名字：";
	getline(cin, player->name);	//因为是指针，所以需要用->符号
	cout << "请输入攻击力：";
	cin >> player->str;
	cout << "请输入防御力：";
	cin >> player->def;
	cout << "请输入生命值：";
	cin >> player->hp;
	cout << "请输入魔法值：";
	cin >> player->mp;
	cout << "请输入幸运：";
	cin >> player->luck;
	cout << "请输入金钱：";
	cin >> player->gold;
	return player;
}

void combat(shuxing *player)	//参数是结构指针，无返回值
{
	int zhandouli;
	zhandouli = (player->str * 5 + player->def * 2 + player->hp * 1 + player->mp*0.8)*(player->luck / 30 + 1) + player->gold*0.001;
	cout << player->name << "的战斗力为：" << zhandouli << endl;
}

注意：

①当结构的变量通过指针使用时，需要使用运算符“->”或者是“(*指针名).结构变量名”，如player->str；

②当传递的参数为指针（结构地址）时，除了使用指针名之外，还可以直接使用“&结构名”作为参数，即在结构名前加上地址运算符“&”；

例如，将

shuxing *player_1=wanjia(); //注意，这里返回的是结构指针

combat(player_1);

改为：

shuxing player_1=wanjia(); //注意，这里返回的是结构

combat(&player_1); //结构名前加上地址运算符&

就第二个函数combat而言，效果是一样的，只不过前者是传递一个结构指针，后者是传递了一个结构地址。