c++函数调用

一个函数就是完成一项任务的独立代码块，它以名字作为整个代码块的代表

函数完成任务后，如果有数值需要返回，则在声明函数时，在函数名前写好返回值类型

如果不需要返回任何值，则在函数名前写 void

有时，一个函数还需要传入一些参数，参数列表写在函数名后的一对小括号中

参数列表是用逗号隔开的，每个参数都要注明其类型

即使没有参数需要传入，函数名后的小括号也不能省略

通常函数名以“动词+名词”的方式命名，中间以一个下划线隔开（C\C++风格）

#include <cstdio>
int add(int a, int b) {
    return a + b;
}
int main() {
    int x, y;
    scanf("%d%d", &x, &y);
    printf("%d", add(x, y));
    return 0;
}

---

函数的定义和调用

1，模块化：一个较大的程序一般应分为若干个程序模块，每个模块用来实现一个特定的功能

2，模块（C 函数）是由完成一特定任务的说明语句和执行语句组成的基本功能单元。可提供给主程序或其它函数使用，函数执行完毕后，返回一个结果给调用程序。如此可以减少重复编写程序段的工作量，来提高软件开发的时间效率

3，一个程序中函数调用的示意图（如下）

举个例子：

#include <iostream>

void printstar()          //输出一排星号函数
{
    cout << "***************************\n";
}

void print_message() //输出一行信息函数
{
    cout << "      How do you do!\n";
}

int main( )
{  
    printstar();        //调用 printstar 函数
    print_message();    //调用 print_message 函数
    printstar();         //调用 printstar 函数
   return 0;
}

输出结果：

*************************** 
                How do you do! 
***************************

说明

1，在 C++ 中，所有程序模块都被当作函数对待

2，一个源程序文件由一个或多个函数组成。一个源程序文件是一个编译单位，而不是以函数为单位进行编译

3，一个 C++ 程序由一个或多个源程序文件组成。对较大的程序，一般不希望全放在一个文件中，而将函数和其它内容分别放到若干个源文件中，再由若干源文件组成一个C++ 程序。这样可以分别编写、分别编译，提高调试效率。一个源程序文件可为多个 C++ 程序公用。

4，C++ 程序的执行总是从 main 函数开始，调用其它函数后流程返回到 main 函数，在 main 函数中结束整个程序的运行。main 函数是系统定义的

5，所有函数都是平行的，即在定义函数时是互相独立，一个函数并不从属于另一个函数，即函数不能嵌套定义

6，函数间可以相互调用，但不能调用 main 函数，main 函数可调用所有函数

函数的基本定义

~声明、定义、调用~

1. 函数声明

告诉编译器它所提供的名字是一个函数的名称；在源代码中使用时它所需要的数据类型；在完成时它将会返回的数据的类型

2. 函数定义（函数实现）

是一组指令，告诉编译器一个函数是如何执行任务的

3. 函数调用（函数使用）

即使用这个函数

函数的声明和调用

·函数是面向对象程序设计中，对功能的抽象

·函数定义的语法形式

类型标识符  函数名（形式参数表）                        
{  
   语句序列
}

形式参数表

<type_1> name_1, <type_2> name_2, ..., <type_n> name_n

函数的返回值

·由 return 语句给出，例如：return 0

·无返回值的函数（void类型），不必写return语句。

形式参数和实际参数

·大多数情况下，主调函数和被调用函数之间有数据传递关系。

·在定义函数时，函数名后面括弧中的变量名称为“形式参数”（简称“形参”）。

·在调用函数时，函数名后面括弧中的表达式称为“实际参数”（简称“实参”）。

形参

·在被定义的函数中，必须指定形参的类型

·在定义函数时指定的形参变量，在未出现函数调用时，它们并不占内存中的存储单元；只有在发生函数调用时，函数 max 中的形参才被分配内存单元

·在调用结束后，形参所占的内存单元也被释放

实参

·实参可以是常量、变量、表达式 、指针，但要求它们有确定的值

·在调用时将实参的值赋给形参变量

·实参与形参的类型应一致，否则发生“类型不匹配”的错误。字符型与整型可以互相通用

·调用结束后，实参单元仍保留

函数返回值

~通常，希望通过函数调用使主调函数能得到一个确定的值，这就是函数的返回值~

·函数的返回值通过函数中的 return 语句获得的，语句格式：

return ; //仅返回程序执行的控制权

return 表达式 ; //返回控制权及函数值

·先计算出表达式的值，然后按函数类型返回给调用函数作为调用函数的值

·一个函数可有 1 个以上的 return 语句

·如无返回语句 return，则在执行完最后一个语句时，把控制返回到调用函数。返回后，从调用函数处继续往下执行

凡不加类型说明的函数，函数值的类型一律自动按整型处理

如果函数值的类型和 return 语句中表达式的值不一致，则以函数类型为准。即函数类型决定返回值的类型

·一般，函数返回一个值。为了明确表示“不返回值”，一般应用 “ void ” 定义为 “无类型”（或称“空类型”），以此保证正确调用，使程序减少出错

例子

输出两个数的最大值：

#include <bits/stdc++.h>
using namespace std;
int  max ( int x,  int y )
{
    return   x>y ? x : y;   
}

int main( )
{  
    int a,b;
    cin >> a >> b;
    cout << "max=" << max(a,b);
    return 0;
}

函数的声明与使用

1,调用前先声明函数原型：

·在调用函数中，或程序文件中所有函数之外，按如下形式说明：

·类型标识符 被调用函数名 （含类型说明的形参表）;

2,调用形式

·函数名（实参列表）

3,嵌套调用

·函数可以嵌套调用，但不允许嵌套定义。

4,递归调用

·函数直接或间接调用自身。

按函数在程序中出现的位置来分，可以有以下三种函数调用方式：

1，函数语句
    把函数调用作为一个语句，此时不要有返回值，如：printstar( );

2，函数表达式
    函数出现在表达式中，要求函数返回一个确定的值，如：c = 2*max(a,b);

3，函数参数
    函数调用得到的值又作为另一个函数的实参，如：m = max(a, max(b, c));

注意：

~对函数的“定义”和“声明”不是一回事~

1，函数定义是指对函数功能的确立，包括指定函数名、函数值类型、形参及其类型、函数体等，它是一个完整的、独立的函数单位。

2，函数声明（即函数原型的声明）是使编译器可以检查传入函数的参数个数、类型和顺序，它不包括函数体，以便在主调函数中按此类型对函数值作相应的处理。

例子

如果将函数的主体写在调用程序的前面，则函数可以不必事先声明

#include  <iostream>
int  max( int x,  int y )
{
    int z;
    z = x>y ? x : y;
    return z;
}
int  main( )
{
    int a,b,c;
    cin >> a >> b;
    c = max(a,b);
    cout << "max=" << c;
    return 0;
}

如果写在调用程序的后面，则必须事先声明函数的原型，避免发生编译错误。因为编译器在编译程序时，是从程序的第一行开始逐行编译，如果先调用，则无法分配执行该函数的地址。

#include  <iostream>
int max( int,  int );  //函数原型声明
int  main( )
{
    int a,b,c;
    cin >> a >> b;
    c = max(a,b);
    cout << "max=" << c;
    return 0;
} 
int  max( int x,  int y )
{
    int z;
    z = x>y ? x : y;
    return z;
}

递归调用

·函数直接或间接地调用自身，称为递归调用。

·递归过程的两个阶段：

1，递推：4!=4×3! → 3!=3×2! → 2!=2×1! → 1!=1×0! → 0!=1（未知转已知）

2，回归：4!=4×3!=24←3!=3×2!=6←2!=2×1!=2←1!=1×0!=1←0!=1（已知转未知）

函数的参数传递机制

1，参数就是主调函数传递给被调函数的数据变量，是两者的沟通渠道

2，引入参数，使得函数的运用更加灵活。

3，参数传递的方法：

1）传递变量本身的值—传值调用

2）传递变量地址的值—传址调用

3）传递变量地址的值—引用调用（C++ 中）

4，主调函数与被调用函数参数表中的参数个数、参数类型、参数顺序应注意保持一致

传递参数值

·在函数被调用时才分配形参的存储单元。

·实参可以是常量、变量或表达式。

·形参只能是变量。

·实参类型必须与形参相符。

传递时是传递参数值，即单向传递。

用引用做形参

·引用(&)是标识符的别名

·引用定义格式：

类型 &引用名( 变量名 );

或类型 &引用名=变量名;

·例如:

        int i,j;int &ri=i;//建立一个int型的引用ri,并将其      //初始化为变量i的一个别名
        j=10;ri=j;//相当于 i=j;

·声明一个引用时，必须同时对它进行初始化，使它指向一个已存在的对象。

·一旦一个引用被初始化后，就不能改为指向其它对象。

·引用可以作为形参 void swap(int& a, int& b) {...}

·引用作函数形参时，调用函数的实参要用变量名

将实参变量名赋给形参的引用，相当于在被调用函数中使用了实参的别名

特点：

在被调用函数中，对引用的改变，实质就是直接改变实参的变量值

·引用调用起到传址调用的作用，但它又比传址调用更方便、更直接

内联函数声明与使用

1，声明时使用关键字 inline。

2，编译时在调用处用函数体进行替换,节省了参数传递、控制转移等开销。

注意：

3，·内联函数体内不能有循环语句和switch语句。

·内联函数的声明必须出现在内联函数第一次被调用之前。

·对内联函数不能进行异常接口声明。

默认形参值的作用

~

函数在声明时可以预先给出默认的形参值，调用时如给出实参，则采用实参值，否则采用预先给出的默认形参值。

~

默认形参值的说明次序

1，默认形参值必须从右向左顺序声明，并且在默认形参值的右面不能有非默认形参值的参数。因为调用时实参取代形参是从左向右的顺序。

·例：

    int add(int x,int y=5,int z=6); //正确
    int add(int x=1,int y=5,int z); //错误
    int add(int x=1,int y,int z=6); //错误

默认形参值与函数的调用位置

1，调用出现在函数体实现之前时，默认形参值必须在函数原形中给出；而当调用出现在函数体实现之后时，默认形参值需在函数实现时给出。

·例：

#include <bits/stdc++.h>
using namespace std;
int add(int x=5,int y=6){
    return x + y;
}
int main()
{   add(); //调用在实现后
}

int add(int x=5,int y=6);
int main()
{   add(); //调用在实现前
}
int add(int x,int y){   
    return x+y;   
}

默认形参值的作用域

1，在相同的作用域内，默认形参值的说明应保持唯一，但如果在不同的作用域内，允许说明不同的默认形参。

·例：

int add(int x=1,int y=2);
int main()
{  int add(int x=3,int y=4);
    add();  //使用局部默认形参值（实现3+4）
}
void fun(void)
{   ...
     add();  //使用全局默认形参值（实现1+2）
}

重载函数的声明

1，C++允许功能相近的函数在相同的作用域内以相同函数名声明，从而形成重载。方便使用，便于记忆。

·例：

int add(int x, int y);
float add(float x, float y);
//形参类型不同
int add(int x, int y);
int add(int x, int y, int z);
//形参个数不同

c++系统函数

1，C++的系统库中提供了几百个函数可供程序员使用。

·例如：求平方根函数（sprt）、求绝对值函数（abs）等。

2，使用系统函数时要包含相应的头文件。

·例如：math.h 或 cmath

---

以上如有侵权，请联系，将删除。

制作不易，点个赞吧！