C/C++笔记：函数

返回类型 函数名称（参数，参数，...）
{
         函数的功能区
         return 返回值；
}

int Add (int a, int b)
{
     char c = a + b;
     return c;
}

指针参考：C++笔记：指针（1）

int add(int* a, int* b) {
   (*a)  += 100;
   (*b)  += 10;
   return (*a) + (*b);
}
int main() {
   int a = 2, b= 1;
   int c = add(&a, &b);
}

1. 使用结构体，参数Role rl 占用内存16字节；

struct Role {
	int hp;
	int mp;
	int dp;
	int lp;
};

int Exp(Role rl) {
	return rl.hp + rl.mp + rl.dp + rl.lp;
}

int main()
{
	Role rl{ 200, 300  100， 50};
	int c = Exp(rl);
}

2. 使用指针参数Role * rl,才占用8个字节（64位指针占用8个字节。42位4个字节）

int Exp(Role* rl) {
	return rl->hp + rl->mp + rl->dp + rl->lp;
}

int main()
{
	Role rl{ 200, 300  100， 50};
	int c = Exp(&rl);
}

因为数组的本质是一块连续的内存，所以数组参数本质还是传递指针，但是数组内存是连续的，所以除了指针，还必须要有元素的数量；
申明方式：

• 返回值 函数名(数组参数, unsigned count) （推荐这种。同下，底层一样，效率一样，这种便于阅读。）
• 返回值 函数名(指针参数, unsigned count)

void Sort(int ary[], unsigned count) 
{
	std::cout << sizeof(a);
}
void Sort(int* a, unsigned count) 
{
	std::cout << sizeof(a);
}
int main()
{
	int a[5]{ 23, 33, 24, 26 };
	Sort(a, 5);
}

• 注意：多维数组参数 第二维一定要指定具体数值，只能有第一维的变量；

void Sort(int ary[][2], unsigned cout) {

}
int main() {
    int a[3][2]{{1, 2,}, {3, 4}, {5, 6}};
    Sort(a, 3);
}

引用：C++笔记：引用;
注意：指针可以传入nullptr空指针，而引用不可以。

struct Role 
{
   int hp;
   int mp;
   int damage;
}
bool Act(const Role& Acter, Role*& beAct) 
{
   beAct->hp -= Acter.damage;
   return beAct->hp < 0;
}
int main() 
{
   Role user {200, 300, 1000};
   Role monster {80, 90, 200};
   Role* pRole = &monster;
   if(Act(user, pRole)) std::cout <<"123"<< std::endl;
}

解析：Role*& beAct: Role*指针类型的引用，所以本质还是一个引用；

格式：

• void Sort(int ary[], unsigned count, bool bigSort = true);

注意：默认参数只能放在最后。

int main(int argcount, char* c_arg[])
{
	std::cout << "一共有" << argcount << "个参数" << std::endl;
	for (int i = 0; i < argcount; i++) std::cout << "参数【" << i << "】=【" << c_arg[i] << "】n";

	for (int i = 0; c_arg[i]; i++) std::cout << "参数【" << i << "】=【" << c_arg[i] << "】n";
}

E:LearnC++函数_1Debug>test id:123 pass:qwe country:China

char* ReadRef(const char*ref, const char* cmds) 
{
	for (int i = 0; cmds[i]; i++) 
	{
		if (cmds[i] == ref[0]) 
		{
			bool bfind = true;
			int x;
			for (x = 0; ref[x]; x++)
			{
				if (ref[x] != cmds[i + x])
				{
					bfind = false;
					break;
				}
			}
			if (bfind) return (char*)&cmds[i + x];
		}
	}
	return nullptr;
}

int main(int count, char* arc[]) {
	char* id{};
	char* pass{};
	char* country{};
	const char* idRef{ "id:" };
	const char* passRef{ "pass:" };
	const char* countryRef{ "country:" };
	for (int i = 1; arc[i]; i++)
	{
		if (id == nullptr)
		{
			id = ReadRef(idRef, arc[i]);
			if (id != nullptr) continue;
		}
		if (pass == nullptr)
		{
			pass = ReadRef(passRef, arc[i]);
			if (pass != nullptr) continue;
		}
		if (country == nullptr)
		{
			country = ReadRef(countryRef, arc[i]);
			if (country != nullptr) continue;
		}
	}

	if ((int)id* (int)pass * (int)country)
	{
		std::cout << "账号：" << id << std::endl;
		std::cout << "密码：" << pass << std::endl;
		std::cout << "国家：" << country << std::endl;
	}
	else
	{
		std::cout << "格式错误" << std::endl;
	}
}