C++笔记（六.五）——函数、函数重载

雨点打透心脏的1/2处 2022-05-17 13:43 217阅读 0赞

# 一、函数的组成 #

通常情况下，函数包括返回值类型、函数名、参数列表和函数体4部分。其中，返回值类型、函数名和参数列表构成了一个函数原型，而*函数体*表示*函数的实现*。

<table style="width:500px;"> 
 <tbody> 
 <tr> 
 <td> 返回值类型 函数名（参数列表） { &nbsp; &nbsp; 函数体； } </td> 
 </tr> 
 </tbody> 
</table>

通常，**函数名**可以是*任何合法的标识符*。

函数的**参数列表**是*可选的*，若函数不需要参数，则可以省略参数列表，但是参数列表两边的括号不能省略。

**函数体**描述的是*函数的功能*，主要*由一条或多条语句构成*。函数也可以没有函数体，此时的函数称为空函数，空函数不执行任何动作。

函数都有一个**返回值**，当函数结束时，*将返回值返回给调用该函数的语句*。但是，函数也可以没有返回值。即返回值类型为void。

# 二、函数的值传递和引用传递 #

在C++中，***函数参数***主要采用***两种传递方式***，值传递和引用传递。

<table> 
 <tbody> 
 <tr> 
 <td>&nbsp;</td> 
 <td>值传递</td> 
 <td>引用传递</td> 
 </tr> 
 <tr> 
 <td> 定义 ，区别 </td> 
 <td>是指在调用函数时，将实际参数复制一份传递到函数中，这样在函数中如果对参数进行修改，将不会影响到实际参数</td> 
 <td>是指在调用函数时将实际参数的地址传递到函数中，其在函数中对参数所进行的修改，将影响到实际参数</td> 
 </tr> 
 <tr> 
 <td>判断方法</td> 
 <td>其他情况是值传递</td> 
 <td>根据参数的数据类型来判断，若参数类型是指针、引用或数组类型，是引用传递</td> 
 </tr> 
 <tr> 
 <td>eg.</td> 
 <td> void output(int&nbsp;Number) { &nbsp; &nbsp;cout &lt;&lt; number&nbsp; &lt;&lt; '\n'； &nbsp; &nbsp; Number = 20; } int main(int argc, char* argv[]) { &nbsp; &nbsp; int nNum = 10; &nbsp; &nbsp; output(nNum); &nbsp; &nbsp; cout &lt;&lt; nNum&nbsp; &lt;&lt; '\n'； &nbsp; &nbsp; return 0; } 结果：10&nbsp; 10&nbsp; </td> 
 <td> void output(int &amp;Number) { &nbsp; &nbsp;cout &lt;&lt; number&nbsp; &lt;&lt; '\n'； &nbsp; &nbsp; Number = 20;&nbsp; } int main(int argc, char* argv[]) { &nbsp; &nbsp; int nNum = 10; &nbsp; &nbsp; output(nNum); &nbsp; &nbsp; cout &lt;&lt; nNum&nbsp; &lt;&lt; '\n'； &nbsp; &nbsp; return 0; } 结果：10&nbsp; 20&nbsp; 因为Number处将值改为20，所以此时nNum为20 </td> 
 </tr> 
 </tbody> 
</table>

指针类型的引用传递：

void OutputNum(int* pNumber)
 {
 cout << *pNumber << '\n';
 *pNumber = 20;
 }
 
 int main (int argc, char* argv[])
 {
 int nNum = 10;
 OutputNum(&nNum);
 cout << nNum << '\n';
 return 0;
 }

结果： 10   20

## 三、省略号参数 ##

省略号参数代表的含义是**函数的参数是不固定的，可以传递一个或多个参数**。

在编写函数体时需要一一读取用户传递的实际参数，可以使用***va\_list***类型和***va\_start、va\_arg、va\_end*** 3个宏读取传递到函数中的参数值。

## ![70][] ##

## ![70 1][] ##

## 四、内联函数 ##

当用户定义一个函数时，编译器会在内存中为其创建一个指令，当**调用函数时**，**程序将跳转到相对应的指令集处执行，在函数执行完后，再回到调用函数的下一行继续执行。**如果调用一个函数5次，程序就会在指令集间跳转5次。**任何时候，内存中只有一个函数拷贝**。

在声明函数时，如果使用**inline**关键字，该函数就会成为内联函数。当程序调用内联函数时，编译器并不会创建真实的函数，而是**将函数的代码复制到被调用函数的地方**。这样，程序的跳转就不存在了。

好处：减少跳转次数，提高运行效率。

坏处：

# 五、重载函数 #

**        所谓重载函数是指多个函数具有****相同的函数名称****，而****参数类型或参数个数不同****。函数调用时，编译器以参数的类型及个数来区分调用哪个函数。**

#include <iostream.h>
 
 int Add(int x, int y)
 {
 cout << "整型参数的函数被调用" << '\n';
 return 0;
 }
 
 double Add(double x, double y)
 {
 cout << “双精度浮点型参数的函数被调用” << '\n';
 return 0;
 
 }
 
 int main(int argc, char* argv[])
 {
 Add(3, 5);//因为函数的参数数量相同，所以通过参数类型来调用相应函数
 return 0;
 }

**注意事项**

**1. 函数的返回值类型不作为区分重载函数的一部分。**

**2.** **对于普通的函数参数来说****const****关键字不作为区分重载函数的标识。**

**3.** **如果参数的类型是指针或引用类型，则****const****关键字将作为重载函数的标识。**

**4.** **参数的默认值不作为区分重载函数的标识。**

**5.** **使用****typedef****自定义类型不作为重载的标识。**

#include <iostream>
 
 using namespace std;
 typedef int INT;
 
 int Add(int x, int y)
 {
 cout << "整型参数的函数被调用" << '\n';
 return 0;
 }
 
 int Add(int x, INT y)
 {
 cout << "INT整型参数的函数被调用" << '\n';
 return 0;
 }
 
 int main()
 {
 //Add(3, 5);
 return 0;
 }

# 六、函数的递归调用 #

在***函数体中***的**直接或间接调用函数本身**，称为函数的递归调用。递归分为**直接递归**和**间接递归**。直接递归是函数直接调用其本身，间接递归是**函数调用另一个函数，而被调用函数又调用了第一个函数**，使用函数递归能够化简复杂的数学运算。

代码例子参见C笔记的递归调用。

**注意事项：**

**1. 在开发程序时，如果有其他算法能解决问题，就不要采用递归算法，因为递归非常浪费系统资源。**

**2.** **对于递归函数来说，必须具有终止条件，无限制的递归将导致程序崩溃。**

# **七、函数指针** #

**       ** 对于C++语言来说，**函数名**实际上是**指向函数的长指针**。理解这一点，就可以定义一个普通的函数指针，使其指向**某一类型的函数**。

下面是两种定义方法：

**（1）形式1：返回类型(\*函数名)(参数表) ；**

下面的代码定义了一个指向具有两个整型参数的函数指针。

**        int (\*ptfun)(int,int);//前面的指针表示返回值，ptfun表示函数指针的类型（自己定），后面是两个整型参数**

char (*pFun)(int); 
    
    char glFun(int a)
    { 
      return;
    }  
    
    void main() 
    { 
        pFun = glFun; //函数名实际上是长指针
        (*pFun)(2); 
    }

第一行定义了一个指针变量pFun。首先我们根据前面提到的“形式1”认识到它是一个指向某种函数的指针，这种函数参数是一个int型，返回值是char类型。只有第一句我们还无法使用这个指针，因为我们还未对它进行赋值。  
         第二行定义了一个函数glFun()。该函数正好是一个以int为参数返回char的函数。我们要从指针的层次上理解函数——函数的函数名实际上就是一个指针，函数名指向该函数的代码在内存中的首地址  
         然后就是main()函数了，它的第一句您应该看得懂了——它将函数glFun的地址赋值给变量pFun。main()函数的第二句中“\*pFun”显然是取pFun所指向地址的内容，当然也就是取出了函数glFun()的内容，然后给定参数为2。

**（2）使用typedef定义一个函数指针类型，然后定义该类型的变量**。

形式：typedef  返回类型(\*新类型)(参数表)；

<table style="width:500px;"> 
 <tbody> 
 <tr> 
 <td> typedef int (*ptfun)(int,int); ptfun fun;//fun表示变量 </td> 
 </tr> 
 </tbody> 
</table>

typedef char (*PTRFUN)(int，int); //定义一个指针变量类型PTRFUN，该类型函数要输入两个int型参数，输出一个char型
    
    PTRFUN pFun; 
    
    char glFun(int a)
    { 
      return;
    } 
    
    void main() 
    { 
        pFun = glFun; 
        (*pFun)(2); 
    }

**       **   typedef的功能是**定义新的类型**。第一句就是定义了一种PTRFUN的类型，并定义这种类型为指向某种函数的指针，这种函数以一个int为参数并返回char类型。后面就可以像使用int,char一样使用PTRFUN了。  
           第二行的代码便使用这个新类型定义了变量pFun，此时就可以像使用形式1一样使用这个变量了。

**对于函数指针来说，它指向的函数必须与****函数指针定义的函数形式相同****，即返回值类型相同、参数类型相同、参数个数相同。**

**在程序中使用函数指针的好处是增强程序的灵活性。**

#include <stdio.h>
 #include <assert.h>
 
 typedef int (*FP_CALC)(int,int);//定义一个函数指针类型
 
 int add(int a, int b)
 {
 	return a + b;
 }
 
 int sub(int a, int b)
 {
 	return a - b;
 }
 
 int mul(int a, int b)
 {
 	return a * b;
 }
 
 int div(int a, int b)
 {
 	return b ? a/b : -1;
 }
 
 //定义一个函数，参数为op，返回一个指针,该指针类型为拥有两个int参数、
 //返回类型为int的函数指针。它的作用是根据操作符返回相应函数的地址
 FP_CALC calc_func(char op)
 {
 	switch( op )
 	{
 	case '+':
 		return add;
 	case '-':
 		return sub;
 	case '*':
 		return mul;
 	case '/':
 		return div;
 	default:
 		return NULL;
 	}
 	return NULL;
 }
 
 //s_calc_func为函数，它的参数是 op， 
 //返回值为一个拥有两个int参数、返回类型为int的函数指针 
 int (*s_calc_func(char op)) (int , int)
 {
 	return calc_func(op);
 }
 
 //最终用户直接调用的函数，该函数接收两个int整数，
 //和一个算术运算符，返回两数的运算结果
 int calc(int a, int b, char op)
 {
 	FP_CALC fp = calc_func(op);
 	int (*s_fp)(int,int) = s_calc_func(op);//用于测试
 
 	assert(fp == s_fp);// 可以断言这两个是相等的
 
 	if(fp)
 		return fp(a,b);
 	else
 		return -1;
 }
 
 void main()
 {
 	int a = 100, b = 20;
 
 	printf("calc(%d, %d, %c) = %d\n", a, b, '+', calc(a, b, '+'));
 	printf("calc(%d, %d, %c) = %d\n", a, b, '-', calc(a, b, '-')); 
 printf("calc(%d, %d, %c) = %d\n", a, b, '*', calc(a, b, '*')); 
 printf("calc(%d, %d, %c) = %d\n", a, b, '/', calc(a, b, '/')); 
 }

参考：[https://blog.csdn.net/qll125596718/article/details/6891881][https_blog.csdn.net_qll125596718_article_details_6891881]

[70]: /images/20220517/f32617835337489f94fb9af9d0f6e5fb.png
[70 1]: /images/20220517/69154f8dc80f46d4bad8df93b4d72d92.png
[https_blog.csdn.net_qll125596718_article_details_6891881]: https://blog.csdn.net/qll125596718/article/details/6891881