《C和指针》阅读笔记(6)

本文继续总结《C和指针》第7章的内容，本章的内容由6个部分构成：函数定义、函数声明、函数参数、ADT、递归与迭代、可变参数列表。

函数定义

ANSI C标准的函数语法形式:

// 风格１
类型　函数名(形式参数)
代码块

// 风格２
类型
函数名(形式参数)
代码块

//　例如
int func1(int a, int b)
{
    // statements;
}

int
func2(char a, float b)
{
    
}

K&R C旧标准的函数语法形式:(了解一下即可)

特别的地方在于形参的数据类型以单独的列表进行声明，并放置在右小括号和左花括号之间。

// 例如
int func(name, id)
char name;
int id;
{
    
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-hFfLiw8p-1604386343056)(KRC_func_definition.png)]

K&R C 旧式标准在形参的定义上冗余；ANSI C标准更加简单自然。

函数声明

当编译器要处理一个函数调用时，显然编译器需要知道函数的详细信息，如，形参个数、形参类型、函数是否有返回值。那么要怎样获取到这些信息呢？

一种策略是编译器假定函数的形参类型、个数是正确，即不做任何检查；假定函数将返回一个整数值；显然这种策略是极不靠谱的，会导致各种异常的发生。

另一种策略是按照函数定义，由程序员向编译器提供函数的相关信息。实现方法有两种：

• 方法1

  在同一源文件中，始终遵循函数定义在函数调用之前，这样编译器在自上而下编译代码时，就能"记住"函数的相关信息，这样在后续函数调用时就能对函数的相关信息进行检查；

• 方法2

  通过函数原型(function prototype)向编译器提供函数的相关信息。

两种方法相比较而言，方法2更加的方便灵活且更不容易出错。

函数原型的声明在工程上建议放在头文件中，当源文件需要使用该函数时，只需要通过#include指令包含头文件即可。这样做的好处有两点(也是一个好的习惯，要养成)：一是减少反复键入原型出错的可能性；二是提高代码的可维护性。

关于编译器对函数的处理，有两个点需要注意：1. 返回值缺省认定；2. 缺省参数提升

返回值缺省认定：当调用一个没有原型声明的函数时，编译器会认为该函数返回一个整形值。所以所有函数都应该声明原型。

缺省参数提升：对于没有原型声明的的函数，传递给函数的实参的类型可能会被提升：char和short转换为int，float转为double。

返回值缺省认定和缺省参数提升的问题，如果你养成了好的编码习惯，这些问题都不会出现。所以良好的编码习惯可以提高工程效率，这在实际工作当中是非常重要的。

函数参数的传递

C语言的江湖中，流传着"传值"和"传址"的说法，这种表述更直观的表达了函数参数背后的特点。

“传值” 就是将普通变量的值拷贝一份给形参，函数内部修改形参的值，并不会影响实参的原始值。

“传址” 就是将指针的"值"(这个值是个地址)拷贝给一个形参，函数内部通过间接访问来获取或修改实参的值，这样就会影响实参的原始值。

本质上，C语言的所有函数参数都是传值，只不过在传递指针时，由于指针的间接访问特性，可以修改指针所指向的内存的值。

#include <stdio.h>
#include <stdlib.h>

void add(int a);
void add2(int* a);

// 传值
void add(int a)
{
    a++;
}

// 传址
void add2(int* a)
{
    (*a)++;
}


int main(int argc, char** argv)
{
    int i = 0;

    add(i);
    printf("add(%d)=%d\n", i, i);

    printf("add2(%d)=", i);
    add2(&i);
    printf("%d\n", i);

    return 0;
}

# 输出结果
add(0)=0
add2(0)=1

抽象数据类型(ADT)

使用C语言设计和实现抽象数据类型目的是为了模块化，因为ADT可以限制函数和数据结构的作用域，这种技巧也常被称为黑盒设计。一般来说，模块就是提供功能说明和接口说明，以方便调用者选择和使用；调用者不用关心模块内部的实现细节，只能通过已定义好的接口来访问模块。而限制数据结构和函数的访问的方法就是使用static关键字。ADT的思想基本上在任何工程代码中都能看到，这是非常基础的设计思想。

递归与迭代

递归函数就是直接或间接的调用自身的函数。通常递归是通过函数的stack来实现的。因为每个函数的调用都会先分配stack空间来记录函数的上下文信息，以便函数执行结束后能恢复到正确的位置继续执行，同时stack还会保存函数的参数信息、函数的返回值等。正是由于stack的存在，使得函数递归的实现非常容易。下面，举个例子来感受一下:

// 假设要将整数1234依次按照字符'1'，'2'，'3'，'4'打印出来。当然不是用printf()函数，要自定义一个函数来实现。
/*
 * 采用递归法来打印一个整数
 * 1. 将参数除以10;
 * 2. 判断t的值;t!=0,则调用recurse_print
 * 3. 调用putchar()打印相应的数字字符
 * */
void recurse_print(unsigned int num)
{   
    unsigned int t = 0;
    
    t = num/10;
    if (0 != t)
        recurse_print(t);
    putchar(num%10+'0');
}

/* 递归过程分析
 *
 * recurse_print(1234);
 *     t = 1234 / 10 = 123;
 *     recurse_print(123);
 *         t = 123 / 10 = 12;
 *         recurse_print(12);
 *             t = 12 / 10 = 1;
 *             recurse_print(1);
 *                 t = 1 / 10 = 0;
 *                 putchar(1%10+'0');   // 1. 打印数字字符'1'
 *             putchar(12%10+'0');      // 2. 打印数字字符'2'
 *         putchar(123%10+'0');         // 3. 打印数字字符'3'
 *     putchar(1234%10+'0')             // 4. 打印数字字符'4'
 *
 * */

// 从上面的调用过程可以看出，recurse_print的调用逐渐深入
// 可以预想,如果递归深度非常深，那么函数栈开销会非常大，这种情况下就要慎重选择了。
// 所以递归虽好，可不要"贪杯"哦!

一旦理解了递归，阅读递归函数最容易的方法不是纠缠于它的执行过程，而是相信递归函数会顺利完成它的任务。
如果每个步骤都正确无误，结束条件设置正确，并且每次调用之后更接近结束条件，递归函数总是能正确地完成任务。
递归需要满足的两个条件

1. 要有结束条件
2. 每次调用逐渐接近结束条件

刚才提到递归的使用选择也很重要，因为函数的调用会涉及到栈空间分配，参数压栈，局部变量的内存空间分配等等开销，如果一个功能使用了递归而并没有达到提高效率的目的，那么就可以考虑是否有其他更好的方案，比如，迭代。

接下来，看一个经典的例子，用C语言实现阶乘。

#include <stdio.h>
#include <stdlib.h>

/*
 * 数学公式
 * fac(n) = 1            (n <= 0)
 * fac(n) = n * fac(n-1) (n > 0)
 *
 * */

// 递归方式实现
// 找结束条件: n <= 0
unsigned long int factorial_recurse(int n)
{
    if (n <= 0)
       return 1;
    else
        return n*factorial_recurse(n-1);
}

// 迭代方式实现
// 没有了函数调用的开销,显然这种方式效率更高
unsigned long int factorial_iter(int n)
{
    unsigned long int r = 1;

    while(n > 1)
    {
        r *= n;
        n--;
    }
    return r;
}

int main(int argc, char** argv)
{
    unsigned long int recurse = 0;
    unsigned long int iter = 0;
    int n = atoi(argv[1]);
    printf("input numner is %d\n", n);

    recurse = factorial_recurse(n);
    iter = factorial_iter(n);

    printf("recurse:%d!=%lu, %lX\n", n, recurse, recurse);
    printf("iter:%d!=%lu, %lX\n", n, iter, iter);

    return 0;
}

可变参数列表

函数的参数列表中的形参个数通常都是固定个数，有时候也会使用结构体指针作为形参的技巧来接收更多的参数，但形参的个数也还是固定数目。在某些场景下，不同的条件函数接收不同数目的参数，例如，大家都熟知的printf()函数的参数列表就是可变的。

在C语言中，可变参数列表是通过数据类型va_list和三个宏(va_start，va_arg，va_end)来实现的。对于实现了可变参数列表的函数，一定要包含头文件stdarg.h。

#include <stdarg.h>

void va_start(va_list ap, last);
type va_arg(va_list ap, type);
void va_end(va_list ap);
void va_copy(va_list dest, va_list src);

可变参数列表的表示方法是...而且必须在所有固定参数的后面，...不能在固定参数之间，...之前至少要有一个固定参数。va_start()必须最先调用。

// 一般的调用步骤如下:
va_list ap;

va_start(ap, last_arg);

va_arg(ap, type); // va_arg可多次调用，va_arg的返回值即为可变参数列表中对应的形参值

va_end(ap); // va_start和va_end总是成对出现
    
    

下面给出一个简单示例，展示va_*的使用：

#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>

void var_list1(int n, ...)
{
    va_list ap;
    int v = 0;
    int i = 0;

    va_start(ap, n);

    // 假设传入的形参都是int
    for (i = 0; i < n; ++i) 
    {
        v = va_arg(ap, int);
        printf("可变参数列表的第%d个参数是:%d\n", i, v);
    }

    va_end(ap);
}

int main(int argc, char** argv)
{
    printf("5个参数:\n");
    var_list1(5, 1,2,3,4,5);

    printf("7个参数:\n");
    var_list1(7, 1,2,3,4,5,6,7);
                                
    return 0;
}

关注我

我的公众号二维码，欢迎关注

QQ讨论群：679603305