C++函数的参数传递机制以及参数的类型选择
最后更新于：2022-04-01 09:39:11
## C++primer之函数的参数传递以及参数的类型
## 一：函数的基本知识
（1）函数要素：返回类型，函数名字，形参（参数之间用逗号隔开）
（2）函数调用机制：我们通过调用运算符来执行函数，其中运算符就是括号
（3）当我们调用函数时，主调函数被暂停执行，被调函数开始执行，当被调函数遇到return语句时，return语句完成两项工作，1：返回return语句中的值。2：将控制权从被调函数转移到主调函数。函数的返回值用于初始化调用表达式的结果。
（4）函数的实参和形参必须类型一致，或者实参可以通过隐式转换到形参类型
下面举个例子：
~~~
#include<iostream>
using namespace std;
int function(int a) //函数返回类型，名字，参数
{ //函数体
int c=1;
while(a!=1)
{
c=c*(a--);
}
return c; //返回值
}
int main ()
{
cout<<function(5)<<endl; //调用运算符（）执行函数
return 0;
}
~~~
运行结果是：
谈到函数中的参数，他们是局部对象，既生命期就是在函数开始执行到函数结束执行期间（生命期：就是对象在程序中存在的时间），形参和定义在函数中的变量都是局部变量，同时，局部变量会隐藏外层作用域中的同名的变量。
下面举个例子：
~~~
//局部静态变量
#include<iostream>
using namespace std;
int Increase()
{
static int a;
a++;
return a;
}
//与局部变量的区别在于: 在函数退出时,
//这个变量始终存在,静态局部变量延长了局部变量的生命周期.
//但不能被其它 函数使用, 当再次进入该函数时, 将保存上次的结果。
//其它的特点与局部变量一样。
int main()
{
for(int i=0;i<5;i++)
cout<<"After the function,the result is "<<Increase()<<endl;;
//函数调用结束，该变量仍然存在，没有被销毁，继续累加，但是由于是局部的，只能在函数内被访问。
return 0;
}
~~~
## 二：参数传递
（1）传值调用，实参通过拷贝给形参，形参和实参是两个相互独立的对象，两者之间互相不影响。
（2）传引用调用（主推使用，好处多多）：形参是引用类型，即当函数被调用时，形参就是实参的另一个名字，函数中对形参的操纵就是对实参本身的操作（够通俗吧）
（3）指针形参，当执行指针拷贝时，以指针参数传递,指针形参：此时将复制实参的指针：形参的改变不会引起实参的改变，但是形参指向的内容可以发生变化。
文字太乏味，举个例子大家就知道了。
~~~
//三种参数传递传递
#include<iostream>
using namespace std;
int Increase1(int a) //<span style="color:#ff0000;">拷贝的值传递</span>
{
a++;
return a;
}
int Increase2( int &a) //<span style="color:#ff0000;">引用参数传递</span>
{
a++;
return a;
}
int Increase3( int *p) //<span style="color:#ff0000;">指针参数传递</span>
{
(*p)++;
return (*p);
}
int main()
{
int c=5;
Increase1(c);
cout<<"After the Increase1,the result is "<<c<<endl;
//以拷贝的方式进行调用，c的值不会变，
Increase2(c);
cout<<"After the Increase2,the result is "<<c<<endl;
//以引用的形式进行调用，c的值发生改变。
Increase3(&c);
cout<<"After the Increase3,the result is "<<c<<endl;
//以指针参数传递,指针形参：此时将复制实参的指针：形参的改变不会引起实参的改变，但是形参指向的内容可以发生变化。
return 0;
}
~~~
运行截图是：
我们建议使用，引用类型的形参代替指针（指针还是用在函数外边好）.
为什么使用引用参数呢？
我们应该避开那些拷贝传递，拷贝传递费时费力，占资源，使用引用，我们就是直接在对象上操作，不需要拷贝，指针参数也是一样。无论任何是时候，我们都尽量不适用“传值调用”。
使用引用类型的形参还有一个好处就是，我们要从一个函数中得到多个值，而不是单单一个。举个例子，有一字符串，里面有很多单词，要求，计算出第一个第一个空格（也就是第一个单词后的空格），和所有空格数量，此时要计算出两个值，则我们可以如下：
~~~
#include<iostream>
using namespace std;
#include <string>
int find_char(<span style="color:#ff0000;">const string s,int &a</span>)
{
cout<<"the string is "<<s<<endl;
decltype(s.size()) i=0; //i 的类型个s.size 一样
i=s.find(' ',0); //从索引0开始找第一个为空格的，返回索引，失败返回-1
for(auto b=s.begin();b!=s.end();b++) //使用C++迭代器查找string中总的空格数
{
if(*b==' ')
<span style="color:#ff0000;">a++; //这个引用参数虽然没有输出，但是我们仍然可以得到它，这就是引用的好处</span>
}
return i;
}
int main()
{
string s="Zheng zhengzhou university software institute";
int k=0;
cout<<"the blank characters of first index is "<<find_char(s,k)<<endl;
cout<<"the sum of black characters have "<<k<<endl; //引用形参，形参改变，实参也跟着改变。
return 0; //<span style="color:#ff0000;">实现了一个返回值，却可以得到两个有用的参数</span>
}
~~~
## 三：初始化时忽略形参的const特性
我们使用实参初始化形参时，可以忽略形参的顶层const,通俗一点来说，当形参是const类型，实参是否是const 类型都一样。反之也成立（当实参是常量类型，形参是否是常量类型都一样），只是当形参是常量类型，函数中不允许改编实参。
例子如下：
~~~
//实参初始化形参时，可以忽略形参是否是const类型
#include<iostream>
using namespace std;
int add1(const int &a)
{
cout<<a<<endl;
return 1;
}
int add2(int a,int b)
{
cout<<"After the add2,the result is "<<a+b<<endl;
return 1;
}
int main()
{
const int a=9;
int b=10;
add1(a); //形参是常量，实参是非常量,只要在程序中不改变形参的值即可：
add1(b); //使用const实参初始化const形参肯定是没有问题的。
const int c=11;
const int d=12;
add2(c,d); //形参是非常量，实参是常量。
return 0;
}
~~~
上面的例子告诉我们，尽量使用常量的引用，当在函数中不改变参数时，我们设置为常量。把函数不会改变的形参定义成普通的引用是一种常见的错误，这么做带给函数的调用者一种误导，既函数可以修改它的实参值，使用引用而非常量引用也会极大地限制所能接受的实参类型，例如，我们不能把const 对象，传给普通的引用形参。
## 四：形参是数组
当形参是数组时候，若形参是：a[10],a,a[],这三种形式都一样，原理是：数组会被转换成指针，我们外函数传递数组，其实就是为数组传递数组的首元素的指针。
例如一下程序：
~~~
#include<iostream> //显式的传入一个数组大小的参数
using namespace std;
int print(const char *a,int b) //数组作为形参的，传递的其实是手首元素指针，其中参数1也可以写成：a[],a[10]
{
for(int i=0;i<b;i++)
cout<<a[i]<<endl;
return 0;
}
int main()
{
char a[]="helloworld";
//重载函数，编译器根据参数的类型个数判断调用哪个
print(a,10); //其实有11个元素，最后一个元素为空
return 0;
}
~~~
## 五：函数的返回类型
（1）存在返回值，返回值类型与函数返回类型一致，或者可以隐式转换，返回值通过return 返回到主调函数中。其中，一个返回引用的的函数可以充当左值，其原理和变量可以充当左值是一样的。
（2）没有返回值，既renturn ;即可，也可以没有这句话，函数会自动隐式添加这句话。
举个例子
~~~
<span style="font-size:18px;">//返回类型是引用可以当左值
#include<iostream>
using namespace std;
int& function(int &a)
{
cout<<"Before the change,the a is"<<a<<endl;
return a;
}
int main()
{
int a=4;
function(a)=50;
cout<<"after the change,the a is"<<a<<endl;
return 0;
}</span>
~~~
第一遍看C++primer，以后还得多看，多想，多练。暂且到这吧
