C++函数的参数传递机制以及参数的类型选择

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，以后还得多看，多想，多练。暂且到这吧

巴特西

C++函数的参数传递机制以及参数的类型选择

最新文章

热门文章