指针变量作为函数参数

我们说过，函数参数可以是变量，那么既然指针变量也是变量的一种，能否作为函数的参数呢？答案是肯定的！而指针变量作为函数参数的主要作用是，将变量地址传送到函数中。

从例子引入

我们通过两个使用指针变量作为函数参数的例子，来引入我们今天的内容。

问题

输入两个数，返回其中的较大者，设计一个自定义函数进行比较，要求使用指针变量作为函数参数。

解答

#include <stdio.h>
int main(){
    int a, b;
    int abmax(int * pointer_1, int * pointer_2);
    //声明了一个指针变量作为参数的函数
    int * a_pointer, * b_pointer;
    printf("请输入两个数：\n");
    scanf("%d %d",&a,&b);
    a_pointer=&a;
    b_pointer=&b;
    //给指针变量赋值
    printf("%d 和 %d 中较大的是：%d\n",a,b,abmax(a_pointer, b_pointer));
    return 0;
}

int abmax(int *pointer_1, int *pointer_2){
    if (*pointer_1>*pointer_2){
    //接收到指针变量的地址后，对比该地址的数据内容
        return (*pointer_1);
    }else{
        return (*pointer_2);
    }
}

指针变量

前面我们说，存放地址的变量，称为指针变量，那么我们该如何定义和使用指针变量呢？

使用指针变量

我们先从一个例子引入：
问题：先定义2个整型变量，再定义2个指针变量，分别指向这两个整型变量，通过访问指针变量，找到他们所指向的变量，从而获得这些变量的信息。

#include <stdio.h>
int main(){
    int a=1,b=2;  //定义了两个整型变量
    int * a_pointer , * b_pointer;  // 声明了两个指针变量，没有定义
    a_pointer=&a;  // 将变量 a 的地址传给 a_pointer
    b_pointer=&b;  //将变量 b 的地址传给 b_pointer
    printf("a=%d,b=%d\n",a,b); 
    printf("a_pointer=%d,b_pointer=%d\n",* a_pointer,* b_pointer);
    return 0;
}

我们可以看到，输出的时候，其结果是相同的，因为 a_pointer 和 b_pointer 有了 a 和 b 的地址，前面加上*号之后，就代表了该地址所指向的数据内容。

指针

结束了函数的学习，我们进入了 C 语言最经典的核心内容，指针的学习，指针的概念理解比较复杂，使用起来也比较灵活，但是指针是 C 语言的灵魂，只有学会如何使用指针，才能算是学会了 C 语言。

引入指针

在引入指针之前，我们需要知道，数据在内存中是如何存储和读取的，这样才能帮助我们更好的理解指针这个概念。

数据在内存中的存储和读取

程序定义了一个变量，在程序编译时，就会给这个变量分配内存单元。至于内存单元的大小，是变量类型决定的。在 Visual C++ 中，为整型分配4个字节，单精度浮点型分配4个字节，对字符型变量分配1个字节。
内存区的每一个字节都有一个编号，这就是地址。你可以理解为存储柜的箱号，在地址所标志的内存单元中存放的数据则相当于箱子内寄存的物品。
现在，有了地址，我们就能通过地址找到所需要的变量单元，我们就说地址指向该变量单元。我们举个例子：

关于变量的声明和定义

变量我们很早就讲过，现在再提主要是为了区分变量声明和定义的区别。我们知道自定义函数有两部分，分为声明部分和执行语句，声明是将函数的有关信息告诉编译器。而对与变量而言，声明有两种情况，一种是需要建立存储空间的，例如int a=10;，我们在声明变量 a 的同时，对 a 附加了初始值，建立了对应的存储空间，我们称这种为变量的定义性声明。另一种是不需要建立存储空间的int a;，我们称这种为变量的引用性声明。

#include <stdio.h>
int main(){
int a=1;  //我们称之为定义性声明
int b;  //我们称这种没有赋值或者说没有建立存储空间的为引用性声明
}

我们也可以这么理解，声明可以包括定义，定义不一定包括声明，我们可以在声明的时候同时定义，但不能说定义就是声明，因为变量需要先声明后定义。

外部变量只能定义一次，外部变量的声明有多次。因为声明是扩大外部变量的作用域范围，而定义则是必须在初始化的时候进行，因为编译器只根据定义分配存储空间，声明只是表达变量的作用域范围。

局部变量的存储类别 （下）

上面我们讲了自动（auto）变量和静态（static）变量，接下来我们将剩下的部分。

寄存器变量

一般情况下，变量（动态变量或静态变量）一般都存放在内存中，当程序需要用到哪个变量的时候，控制器发出一个指令，将内存中该变量的值发送到运算器中，经过运算器进行运算。如果需要存储数据，那就等运算结束后，再从运算器将数据送回内存。
其实还是蛮好理解的，就是从内存拿了数去运算器运算，算完了结果再返回给内存存储。但是如果遇到一些变量频繁的使用，我们就要频繁的执行取了算-算了存这样的操作，比如我们要循环100000次，这样我们每次存取的过程都会非常浪费时间。
为了解决这样的问题，程序允许我们将数据存放在 CPU 的寄存器中，需要的时候从寄存器中取数据到运算器就好了。你会发现这还是一个取了算-算了存的过程，怎么会解决我们存取时浪费时间的问题呢？

因为数据在 CPU 寄存器中读取的速度远大于在内存中的速度，就好像从老式软盘升级到了 SSD 固态硬盘。所以我们的存取过程的时间大幅度节省了。

变量的存储方式

前面我们说过，变量根据位置的不同，分为不同的作用域。今天我们通过变量存在的时间来观察变量的存储方式。

动态存储方式和静态存储方式

有的变量是在程序运行过程中一直存在，有的则是在调用其所在的函数时才临时分配存储单元，而在函数调用结束后，该存储单元就马上释放了，变量不存在了。综上，我们发现变量根据存在时间的不同，分为动态存储方式和静态存储方式两种。
**静态存储方式：**是指程序在运行期间，由系统分配固定的存储空间。
**动态存储方式：**是指程序运行期间根据需要进行动态的分配存储空间的方式。

不同存储区域下数据的存储和释放

在内存中，可以供用户使用的存储空间分为一下三种：

1. 程序区
2. 静态存储区
3. 动态存储区

引入

我们之前说过变量，可以改变的量即变量，变量还拥有很多种类型，但今天我们要说的是全局变量和局部变量。出了变量类型、变量名、变量的值还有就是变量的作用范围，根据作用范围不同，我们将变量分为全局变量和局部变量两种。
由于之前我们写的程序基本上都在 main 函数中，并且变量一般都在函数开头的地方定义，因为变量要先声明再使用，在 main 函数中的变量，或者说在函数开头声明的变量，只在该函数内有效，也就是只能在该函数内引用。
那么如果我们需要一个变量，能够在多个函数间使用呢？这就引出了变量作用域这个问题了。

三种定义变量的情况

我们线回顾一下，定义变量时，一般有如下三种情况：

1. 在函数开头处定义，这是我们最常用的
2. 在函数内的复合语句内定义，例如 for 语句的计次变量
3. 在函数的外部定义。

数组作为函数参数

在使用有参函数是，我们需要向函数提供参数，参数分为实参和形参。其中实参可以是常量、变量或者表达式，而数组元素和变量用法相同，使用变量时可以使用数组元素代替。所以，数组元素也可以代替函数中的参数，向形参传递数据。

数组元素作为函数的实参

因为数组元素可以代替变量使用，所以在函数参数中的变量，也可以使用元数组素代替使用。但是，数组元素不能作为形参使用，因为形参是函数被调用时的临时分配的存储单元。可以这么理解，函数中的形参，就是一个接收地址，不能是具体的值，随时待命接收实参单向传递来的信息。

例子

我们从一个例子里来看看，数组元素如何作为实参来使用的。
问题：向一个数组中输入10个数，要求设计并使用一个 max 函数，输出其中的最大值。

#include <stdio.h>
int main(){
    int max(int a, int b);
    int num[10];
    int big;
    printf("请输入10个数，程序将返回其中的最大值：\n");
    for (int i=0;i<10;i++){
        scanf("%d",&num[i]);
    }
    big=max(num[0],num[1]);
    for (int i = 2;i<10;i++){
        big=max(big,num[i]);  //这里我们使用 num 数组元素作为 max 函数的实参
    }
    printf("输入的10个数的最大值是：%d\n",big);
}

int max(int a, int b){
    int z;
    z=a>b ? a:b;
    return (z);
}

引入递归

在调用函数的过程中又出现直接或者间接调用函数本身，称为函数的递归调用。
直接调用：

int test(int x){
int a,b;
b=test(a);
return(2*b);
}

这就是直接调用，即在本函数体内，再次调用其自身。

间接调用：

int test (int x){
int test2(int z);
int a,b;
b=test2(a);
return (2*b);
}
int test2 (int z){
int c=2*z;
test(c);
}

上面就是间接调用了，虽然函数体本身并没有调用自身函数，但是调用了其他函数，其他函数又掉用了其主调函数，这就是简介的进行递归。

函数声明

前面我们说，要使用一个函数必须经过两个步骤，声明函数和定义函数，现在我们来讲讲函数的声明。

#include <stdio.h>
int main(){
int max ( int x, int y);  //这里就是对 max 自定义函数的声明
......
return 0
}

上面我们声明了一个函数，函数的名字叫做 max ，返回值类型为 int ，含有两个参数，两个参数的类型都是 int 型。将这些信息告诉编译器之后，编译器就能知道 max 的作用了。

注意
函数声明需要在主调函数内进行，但是如果已经在之前（主调函数前）声明的函数，第二次调用时，不用再次声明。
总之，原则就是，先定义再使用，如果后定义，那就先声明再使用。声明之后，声明位置之后的函数再次调用，不必再次声明。