92.利用函数实现模块化程序设计

利用函数实现模块化程序设计：

1.封装：何为函数的封装,就是把代码封装进去，对调用者来说都话就是因此我们的实现功能。

（1）调用者（外界）对函数的影响--仅限于入口函数。

（2）函数对调用者（外界）的影响--仅限于我们函数的返回值，指针形参。

2.就是检查函数的入口参数的有效合法，检查函数是否调用成功。

3.函数的规模要小。//<80

4.函数的规模要单一。

5.函数结课的定义要清晰。

函数设计的要求：

        可复用性：任何一个提供服务的模块都有可能在其他程序中复用。例如我们的print_ar模块就是可复用的，由于通常很难预测模块的未来使用，因此最好将模块设计成可复用的。

        可维护性：模块化后，程序中的错误通常只影响一个模块实现，也更容易找到并修正错误，在修正了错误之后，重建程序秩序重新编译，该模块实现。然后重新连接整个程序即可，更广泛的说，为了提高性能或将程序移植到另一个平台上，我们甚至可以替换整个模块的实现。

        可读性：上面这些好处都很重要，但其中可无可维护性是最重要的，现实中大多数程序会使用很多年，在使用过程中会发现问题。并做一些改进和修改，以适应需求的变化，将程序按摩快进行设计，会使维护更容易。维护一个程序就像维护一辆汽车一样，修理轮胎应该不需要同时检查引擎。

C语言的函数接口：

        函数的调用者和其实现者之间存在一个协议，在调用函数之前，调用者要为是闲着提供某些条件，在函数返回时，实现者实现调用者需要的功能。

        函数接口通过函数名参数和返回值能描述这个协议，只要函数名和参数名和命名合理。参数的返回值的类型定义的准确，应用者仅仅通过函数接口就能知道函数的用法。

代码：

#include
#include
#include
#define ARSIZE 100
void init_ar(int *br,int n)
{
    int val=0;
    for(int i=0;ibr[j+1])
        {
            swap(&br[j],&br[j+1]);
            tag=false;
        }
        if(tag)
        {
            break;//如果此次循环没有发生交换，则退出
        }
    }
}
int main()
{
    int ar[ARSIZE]={0};
    init_ar(ar,ARSIZE);
    print_ar(ar,ARSIZE);
    bubblesort_ar(ar,ARSIZE);
    print_ar(ar,ARSIZE);
    return 0;
}

结果：

  42  68  35   1  70  25  79  59  63  65
   6  46  82  28  62  92  96  43  28  37
  92   5   3  54  93  83  22  17  19  96
  48  27  72  39  70  13  68 100  36  95
   4  12  23  34  74  65  42  12  54  69
  48  45  63  58  38  60  24  42  30  79
  17  36  91  43  89   7  41  43  65  49
  47   6  91  30  71  51   7   2  94  49
  30  24  85  55  57  41  67  77  32   9
  45  40  27  24  38  39  19  83  30  42

   1   2   3   4   5   6   6   7   7   9
  12  12  13  17  17  19  19  22  23  24
  24  24  25  27  27  28  28  30  30  30
  30  32  34  35  36  36  37  38  38  39
  39  40  41  41  42  42  42  42  43  43
  43  45  45  46  47  48  48  49  49  51
  54  54  55  57  58  59  60  62  63  63
  65  65  65  67  68  68  69  70  70  71
  72  74  77  79  79  82  83  83  85  89
  91  91  92  92  93  94  95  96  96 100