编程语言的精髓：function

presentation

• 函数的作用
  
  • 没有函数的汇编写起来是个什么惨状[1]
    
    • 只有标号和跳转来控制程序流程
    • 单列的代码
  • 将程序划分成不同作用的功能模块
  • 便于多次使用同一个个功能
  • 结构化的程序设计
  • http://lxr.free-electrons.com/source/kernel/ 看看linux各个部分的分模块设计
• 库函数：C语言自身或是其它开发包提供的一套已经写好的函数（#include <>）
• 使用不同的文件将函数声明和定义[2]放在不同的地方（.h和.c分离）
  
  • 更清晰的结构，查看函数使用方法只需知道声明，不必关心实现（定义）
  • 可以只提供编译好的代码库，而不用提供源代码（出于保护目的）
  • 缩小大小，便于包含在不同的工程里
• 自己定义一个函数：返回值类型 函数名（参数类型1 参1，参数类型2 参2）{实现}
• 声明函数：跟定义一样，除去{}的部分，需要分号
• 调用函数：函数名（参数1，参数2...）
• 不要听课上讲的形参和实参，上面3行就足够了
• 宏定义的伪函数：#define MAX(v1,v2) v1>v2 ? v1:v2，使用方法与int max(int v1,int v2)这个真正函数完全相同
  
  • 宏 --> 将一些字替换成另一些字
  • 将MAX(10,5)替换成10>5 ? 10:5
  • 节约函数调用时的开销
  • 替换可读性较差的短代码
• * 宏定义的函数生成器 $^{[↓]}$
• 函数的使用
  
  • 堆栈（stack）
    
    • 后入先出的一种结构
    • 函数嵌套调用的过程：主函数->函数1->函数2；从函数2返回:函数2->函数1->主函数 --> 函数2最后进入，最先退出
  • 函数执行过程中需要一定的内存空间，进入函数时“获取”的空间需要在退出时清理，两种清理的方式（假设caller --> callee）：
    1.被调用的函数自己(callee)清理空间
    2.调用的函数(caller)清理空间
    
    • *调用约定
    • *可变参数函数（printf,scanf）
    • 方法1无法实现可变参数，因为无法得知将会接收多少参数，也就无法清理传递参数占用的那些内存空间；
    • 方法2，caller在调用callee的时候是知道将会传入多少参数的，所以可以帮助callee清理空间，可以实现可变参数
  • 参数传递（数组退化，指针->用于修改外部传入的参数，&和*）（略过）
    
    • 需要修改函数外的变量的值的时候需要传入变量的地址（&var）
  • 返回值
    
    • 向调用者传递本函数结束后的信息，比如A+B之后的值，或函数成功与否
    • main函数的返回值：返回到执行程序的环境，供下一个程序或下一条命令使用
  • 递归（建议自己多写一些来研究）
    
    • 处理可被分解为相似子问题的问题（fibonacci,分治算法）
    • f(x) = f(x-1) + f(x-2) <--都是f(x)这个函数，只是参数有变化
    • 递归的特征：调用自身+边界条件
  • 例子：fibonacci实现

#include <stdio.h>
int f(int x); //数学卷子上写的最多的函数名：f(x)
int main(int argc, char *argv[])
{
    int x,num;
    scanf("%d",&num);//最大
    while(x++<num)
    {   
        printf("%d ",f(x));//依次计算x项的值
    }   
    putchar(10);
    return 0;
}
int f(int x) //计算fibonacci数列第x项的值
{
    if(x==1||x==2)//边界条件：当前这层f(x)的x已到达1或者2
        return 1;//那么不再继续调用自己，而是直接返回
    else return f(x-1) + f(x-2);//调用自己：在下一个“自己”到达边界之前都会继续调用自己，而不会返回
    //当最里层的f(x),x==1||x==2的时候（边界条件）才开始返回
    //最里层的函数返回之后之外所有层的函数都会依次返回
} 

• *黑科技：将第一个程序的函数存起来供第二个程序使用

//program1
#include <stdio.h>
#include <memory.h>
void prog1_func(void *p)
{
    void (*pPUTS)(char*) = p;
    char str[] = {"prog1_func"};
    pPUTS(str);
}
int main()
{
    char buff[1024];
    FILE *fp = fopen("a.r","wb");
    memcpy(buff,prog1_func,1024);//关键点
    fwrite(buff,1024,1,fp);//写入文件
    fclose(fp);
}

//program2
#include <stdio.h>
#include <memory.h>
int main()
{
    char buff[1024];
    FILE *fp = fopen("a.r","rb");
    fread(buff,1024,1,fp);//读
    fclose(fp);
    void (*pfunc)(void*) = (void*)buff;//这行将数组转为函数
    pfunc(puts);//调用原本是数组的函数
}

回顾一下我都讲了些啥：

1. 为什么function被翻译成“函数”；更高级更抽象的语言称之为method（方法）
2. 函数有什么用
   
   1. 让z神找了一段汇编
   2. 程序跟学校院系一样，有结构
   3. 不同的人写不同的功能部分，完成同一个程序
3. 库函数，展示了一下/usr/include里一堆.h头文件，只需了解用法就能在任何程序里直接拿来用
4. 找人上来写了一个max()函数返回两个数里比较大的（讲函数定义）
5. 讲了一下使用函数的方法，告诉大家不要听上课讲的形式参数和实际参数，只需记住定义和调用的格式就够了
6. 大写版的#define MAX(a,b)
7. 黑科技1：函数生成器（自命名），“精通C语言的程度”
8. 堆栈：一句话：后入先出的一种结构
9. 函数嵌套调用的过程，与堆栈一致
10. 两叠纸比喻了好久……还撕坏了别人的作业……讨论函数在进入和离开的时候占用的空间该由谁清理，为什么只有调用者清理空间才能实现printf这种可变参数的函数
11. 参数传递，说明传递地址和传递值的区别（我要告诉你一个秘密，写在纸上把纸给你和直接告诉你有什么区别），为什么想要修改函数外的变量的值只能通过传递地址的方式
12. 返回值的作用，main函数return 233这个数，并在命令行终端中见到了，返回0是约定俗成，出错的命令（command not found）返回了127
13. 递归适用条件：问题能分解成相似的子问题（略了）
14. 写函数递归的两个要点：调用自己和边界条件（略了）
15. 黑科技2，把程序1的函数二进制代码存起来，在程序2里读入并成功执行，如果把存下来的二进制文件删掉，程序2出错，程序2从头到位没定义过任何函数，但却能执行不属于它而属于程序1的函数（没人看懂唉）

#include <stdio.h>
//“函数生成器”
#define decl_typed_mul(TYPE)  TYPE typed_mul_##TYPE(TYPE v1,TYPE v2) {return v1*v2;}
//“函数调用器”
#define call_typed_mul(TYPE,v1,v2)  typed_mul_##TYPE(v1,v2)
decl_typed_mul(int);
/*
上面这行将被替换成：
int typed_mul_int(int v1,int v2) {return v1*v2;} <-注意这是一个完整的函数定义，写成了一行
（就是把int换到了TYPE的位置，##是用来连接的）
*/
decl_typed_mul(double)
//double typed_mul_double(double v1,double v2) {return v1*v2;}
//同样是一个完整的函数定义
int main()
{
        printf("int type mul: %d\n",call_typed_mul(int,10,2));
        //call_typed_mul(int,10,2)被替换为
        //typed_mul_int(10,2)
        //相当于调用了第一个生成的函数
        printf("double type mul: %lf\n",call_typed_mul(double,1.2,3.5));
        //typed_mul_double(1.2,3.5)
        //调用了第二个生成的函数
}