【C语言】学习笔记第9章函数 9.3 实际参数

喜欢ヅ旅行 2024-03-22 10:18 40阅读 0赞

### 【C语言】学习笔记 ###

#### 文章目录 ####

*   *  【C语言】学习笔记
     *   *  第9章 函数
         *   *  9.3 实际参数
             *   *  9.3.1 实际参数的转换
                 *  9.3.2 数组型实际参数
                 *  9.3.3 变长数组形式参数
                 *  9.3.4 在数组参数声明中使用static
                 *  9.3.5 复合字面量

#### 第9章 函数 ####

![在这里插入图片描述][f7387386689845a2aafbc0bf876f517b.png_pic_center]

函数是 C 程序的构建块。每个函数本质上是一个自带声明和语句的小程序。可以利用函数 把程序划分成小块，这样便于人们理解和修改程序。由于不必重复编写要多次使用的代码，函 数可以使编程不那么单调乏味。此外，函数可以复用：一个函数最初可能是某个程序的一部分， 但可以将其用于其他程序。

##### 9.3 实际参数 #####

*  形式参数（parameter）出现在函数定义中， 它们以假名字来表示函数调用时需要提供的值；
 *  实际参数（argument）是出现在函数调用中 的表达式。

在 C 语言中，实际参数是值传递的：调用函数时，计算出每个实际参数的值并且把它赋给 相应的形式参数。在函数执行过程中，对形式参数的改变不会影响实际参数的值，这是因为形 式参数中包含的是实际参数值的副本。从效果上来说，每个形式参数的行为好像是把变量初始 化成与之匹配的实际参数的值。

但是这种特性使得它很难编写某些类型的函数，比如想要真正修改传递过去的变量。

###### 9.3.1 实际参数的转换 ######

C 语言允许在实际参数的类型与形式参数的类型不匹配的情况下进行函数调用。

管理如何 转换实际参数的规则与编译器是否在调用前遇到函数的原型（或者函数的完整定义）有关。

*  编译器在调用前**遇到原型**。就像使用赋值一样，每个实际参数的值被隐式地转换成相应 形式参数的类型。
 *  编译器在调用前没有遇到原型【当然C99 中，这种情况是错误的】。编译器执行默认实参提升：
    
     *  (1) 把 float 类型的实际参 数转换成 double 类型；
     *  (2) 执行整值提升，即把 char 类型和 short 类型的实际参数转 换成 int 类型。（ `C99`实现的是`整数提升`。）
     *  注意：默认实参提升可能会产生一些不期望的结果

###### 9.3.2 数组型实际参数 ######

数组经常被用作实际参数。当形式参数是一维数组时，可以（而且是通常情况下）不 说明数组的长度：

int f(int a[]) /* no length specified */ 
    {
         
     ... 
    }

实际参数可以是元素类型正确的任何一维数组。可惜的是，C 语言没有为函数提供任何简便的方法来确定传递给它的数组的长度。所以如果函数需要这个长度的信息，我们必须把数组长度作为额外的参数提供给它。

> 【注意】使用运算符 sizeof 计算出数组变量的长度，但是它无法给出关于数组型形式 参数的正确答案`后面我们会说明原因`

下面的函数说明了一维数组型实际参数的用法。

int sum_array(int a[], int n) 
    {
         
        int i, sum = 0; 
        for (i = 0; i < n; i++) 
        	sum += a[i]; 
        return sum; 
    }

sum\_array 函数的原型有下列形式：

int sum_array(int a[], int n);
    
    或者
    
    int sum_array(int [], int);

在调用 sum\_array 函数时，第一个参数是数组的名字，第二个参数是这个数组的长度。 例如：

#define LEN 100 
    int main(void) 
    {
         
        int b[LEN], total; 
        ... 
        total = sum_array(b, LEN); 
        ... 
    }

注意，在把数组名传递给函数时，不要在数组名的后边放置方括号

【一个重要的点】\*\*函数无法检测传入的数组长度的正确性。\*\*即它不知道我上面传给它的LEN 到底是不是数组b 的长度。

我们可以 利用这一点来告诉函数，数组的长度比实际情况小。

假设，虽然数组 b 有 100 个元素，但是实 际仅存储了 50 个数。通过书写下列语句可以对数组的前 50 个元素进行求和：

total = sum_array(b, 50); /* sums first 50 elements */

sum\_array 函数将忽略另外 50 个元素。（事实上，sum\_array 函数甚至不知道另外 50 个元素 的存在）

> 注意不要告诉函数，数组型实际参数比实际情况大，这种情况，会导致未定义行为，越界

【还有一个重要的点】函数可以改变数组型形式参数的元素，并且 改变会在相应的实际参数中体现出来。

例如，下面的函数通过在每个数组元素中存储 0 来修改 数组：

void store_zeros(int a[], int n) 
    {
         
        int i; 
        for (i = 0; i < n; i++) 
        	a[i] = 0; 
    }

函数调用

store_zeros(b, 100);

会在数组 b 的前 100 个元素中存储 0。数组型实际参数的元素可以修改，这似乎与 C 语言中实 际参数的值传递相矛盾。事实上这并不矛盾，但现在没法解释，等到后面再解释。

【注意】如果形式参数是多维数组，声明参数时只能省略第一维的长度。

例如，如果修改 sum\_array 函数使得 a 是一个二维数组，我们可以不指出行的数量，但是必须指定列的数量：

#define LEN 10 
    int sum_two_dimensional_array(int a[][LEN], int n) 
    {
         
        int i, j, sum = 0; 
        for (i = 0; i < n; i++) 
        	for (j = 0; j < LEN; j++) 
        		sum += a[i][j]; 
        return sum; 
    }

不能传递具有任意列数的多维数组是很讨厌的。幸运的是，我们经常可以通过使用指针数组 解决这种困难。`C99` 中的变长数组形式参数则提供了一种更好的解决方案。

###### 9.3.3 变长数组形式参数 ######

C99 增加了几个与数组型参数相关的特性。第一个是变长数组，这一特性允许我们用非常 量表达式指定数组的长度。变长数组也可以作为参数。

在之前，

int sum_array(int a[], int n) 
    {
         
        ... 
    }

这样的定义使得 n 和数组 a 的长度之间没有直接的联系。尽管函数体会将 n 看作数组 a 的长度， 但是数组的实际长度有可能比 n 大（也可能比 n 小，这种情况下函数不能正确地运行【未定义行为】）

但是如果使用变长数组形式参数，我们可以显式地说明数组 a 的长度就是 n：

int sum_array(int n, int a[n]) 
    {
         
        ... 
    }

注意，这里交换了形式参数的顺序， 使用变长数组形式参数时参数的顺序很重要。

下面的 sum\_array 函数定义是非法的：

int sum_array(int a[n], int n) /*** WRONG ***/ 
    {
         
         ...
    }

编译器会在遇到 int a\[n\]时显示出错消息，因为此前**它没有见过 n**。

对于这个版本的sum\_array 函数的原型有几种写法：

1.  看起来跟函数 定义一样：
    
        int sum_array(int n, int a[n]); /* Version 1 */
2.  另一种写法是用\*（星号）取代数组长度
    
        int sum_array(int n, int a[*]); /* Version 2a */
    
    星号的使用则为我们提供了一个线索——数组的长度 与形式参数列表中前面的参数相关，还可以省略数组名写成下面这样：
    
        int sum_array(int, int [*]); /* Version 2b */
3.  方括号为空也是合法的
    
        int sum_array(int n, int a[]); /* Version 3a */ 
        int sum_array(int, int []); /* Version 3b */
    
    但是这样并没有说明 n 和 a 之间的关系。

一般来说，变长数组形式参数的长度可以是任意表达式。

比如，假设我们要编写一个函数 来连接两个数组 a 和 b，要求先复制 a 的元素，再复制 b 的元素，把结果写入第三个数组 c：

int concatenate(int m, int n, int a[m], int b[n], int c[m+n]) 
    {
         
     ... 
    }

数组 c 的长度是 a 和 b 的长度之和。

一维变长数组形式参数通过指定数组参数的长度使得函数的声明和定义更具描述性。但 是，由于没有进行额外的错误检测，数组参数仍然有可能太长或太短。

如果变长数组参数是多维的，则更加实用。

\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-CdJjXBb2-1682644902711)(./assets/image-20230410100741800.png)\]

上面我们写的这个，函数要求数组的列数固定而且得给出来，如果使用变长数组形式参数，则可以推广到任 意列数的情况：

int sum_two_dimensional_array(int n, int m, int a[n][m]) 
    {
         
         int i, j, sum = 0; 
         for (i = 0; i < n; i++) 
             for (j = 0; j < m; j++) 
             	sum += a[i][j]; 
         return sum; 
    }

这个函数的原型可以是以下几种：

int sum_two_dimensional_array(int n, int m, int a[n][m]); 
    int sum_two_dimensional_array(int n, int m, int a[*][*]); 
    int sum_two_dimensional_array(int n, int m, int a[][m]); 
    int sum_two_dimensional_array(int n, int m, int a[][*]);

###### 9.3.4 在数组参数声明中使用static ######

C99 允许在数组参数声明中使用关键字 static。【当然C99 之前static 关键字就已经有了，不过传统用法不太一样】

在下面这个例子中，将 static 放在数字 3 之前，表明数组 a 的长度至少可以保证是 3：

int sum_array(int a[static 3], int n) 
    {
         
    	...
    }

这样使用 static 不会对程序的行为有任何影响。static 的存在只不过是一个“提示”，C 编 译器可以据此生成更快的指令来访问数组。【如果编译器知道数组总是具有某个最小值，那么它 可以在函数调用时预先从内存中取出这些元素值，而不是在遇到函数内部需要用到这些元素的 语句时才取出相应的值。】

【注意】如果数组参数是多维的，static 仅可用于第一维 （例如，指定二维数组的行数）。

###### 9.3.5 复合字面量 ######

我们之前写的sum\_array 函数，调用的时候，第一个参数通常是（用于求和的） 数组的名字。例如，可以这样调用 sum\_array：

int b[] = {
        3, 0, 3, 4, 1}; 
    total = sum_array(b, 5);

这样写的唯一问题是需要把 b 作为一个变量声明，并在调用前进行初始化。如果 b 不作他 用，这样做其实有点浪费。

在 C99 中，可以使用复合字面量来避免该问题，复合字面量是通过指定其包含的元素而创 建的没有名字的数组。下面调用 sum\_array 函数，第一个参数就是一个复合字面量：

total = sum_array((int []){
        3, 0, 3, 4, 1}, 5);