一、指针与指针变量

指针：就是地址，一个变量的指针就是这个变量的存储地址。

指针变量：用来存放指针(地址)的变量，指针变量的值是一个地址。

二、指针变量

1、定义指针变量

类型名 * 指针变量名;

int * point;

*表示该变量的类型为指针型变量。前面为基类型，后面为变量名。

一个变量的指针的含义包括两个方面：一个是以存储单元编号表示的地址，一个是它指向的存储单元的数据类型。

定义指针变量时必须指定基类型，必须知道该数据的类型，才能按存储单元的长度以及数据的存储形式正确地取出该数据。

指针类型：//去掉声明与句中的变量名去掉就是指针类型
int *p; //指针类型int *
float *p; //指针类型float *
char *p; //指针类型 char *

2、运算符：& *

& 取地址运算符，&a是变量a的地址

• 指针运算符，*p是指针变量p指向的对象的值。

int a = 100;
int *p = &a; //将a的地址赋给指针变量p

printf("*p:%d\n",*p); //打印p指向的对象的值，即a的值 200
printf("%o\n",(unsigned int)p); //打印指向对象的地址，即a的存储地址；等同于下一句打印
printf("%o\n",(unsigned int)&a);

3、指针的运算

指针可以进行运算，有意义的只是加减运算。并且只有在指针指向数组的时候，其运算才有意义。因为指针变量的值是一个指针/地址，其进行的运算按单元计算，并非简单的加减。

int arr[10] = {1,2,3,4,5,6,7,8};
int *prr = &arr[0]; 
    
for (int i = 0; i < 10; i ++ ) {
    prr ++;
    printf("%d \n",*prr);
}

prr + 1代表移动到下一个元素，prr-1代表移动到前一个元素。对应自增自减prr++,prr--都是有意义的。

三、指针与数组

1、数组元素的指针

数组元素的指针就是数组元素的地址，可以用一个指针变量指向一个数组元素

int arr[10] = {1,2,3,4,5,6,7,8};
int *p = &arr[0];

这里的prr指向数组的地0号元素，也可以理解为是指向数组的指针。在C语言中，数组名(不包括形参数组名，形参数组名不占据实际的内存单元)代表数组中首元素(即第0号元素)的地址。数组是连续存储的一组数据的集合，知道第0号元素指针，以及数组类型，就可以得到所有元素的指针，与数组的下标法取数组元素基本相同。

数组名不代表整个数组，只代表数组首元素地址。

知道数组中某一元素的指针变量，就可以通过加减运算取得所有元素的指针，p+1是下一个元素指针，p-1是前一个元素指针。

*(p+i)或*(arr+i)是p+1和arr+i指向的数组元素，即arr[i]。p是指向首元素的指针。

2、通过指针引用数组元素

引用数组元素有两种方法：

• 1、下标法，a[i]
• 2、指针法，*(p+i),*(a+i),a是数组名，p是指向数组元素的指针变量。

int arr[10] = {1,2,3,4,5,6,7,8};
int *prr = &arr[0];
    
for (int i = 0; i < 10; i ++ ) {
    printf("%d ",*prr);
    prr ++;
    
}
printf("\n");
prr = arr; //重新指向首元素
for (int i = 0; i < 10; i ++ ) {
    printf("%d ",*(prr + i));
}
printf("\n");
    
for (int i = 0; i < 10; i ++ ) {
    printf("%d ",*(arr + i));
    //arr代表数组首元素地址，是常量，在运行过程中，值是固定不变的，无法通过自增取值。
}
printf("\n");

for (int i = 0; i < 10; i ++ ) {
    printf("%d ",arr[i]);
}
printf("\n");

//将数组元素前后倒置。
void evn (int *arr ,int n) { 
    int temp;
    int *i = arr;
    int *p = arr + (n-1)/2;
    int *j = arr + n -1;
    for (; i <= p; i ++,j--) {
        temp = *i; //改变指针指向对象的值
        
        *i = *j;
        *j = temp;
    }
}

int main(int argc, const char * argv[]) {
    int sArr[10] = {1,2,3,5,4,6,7,8,4,9};
    for (int i = 0; i < 10; i ++) {
        printf("%d ",sArr[i]);
    }
    printf("\n");
    evn(sArr, 10);
    for (int i = 0; i < 10; i ++) {
        printf("%d ",sArr[i]);
    }
   printf("\n");
}

3、指针引用多维数组

可以简化多维数组为嵌套的一维数组，如果把多维数组拆分为一个个一维数组，将层次化的一维数组当成元素，那么问题就可以简化为一维数组的引用。

以二维数组为例：

int main(int argc, const char * argv[]) {
    
    int a[3][4] = {{1,2,3,4},{5,6,7,8},{11,22,33,44}};
    
//    数组名a代表数组首元素地址，第一行是一个一维数组，那么a是第一行的这个一维数组的地址。
//    a+0指向a[0]，对应地址&a[0],a+1指向a[1]第二行数组的地址。a+2指向a[2]第二行数组地址。
//    另外，a是第一行一维数组的首地址，也就是第一行第0号元素的地址，即&a[0][0].*(a+0)+0
    
//    分层理解，对应的值与地址的关系。
//    理解：
//    a[0] :对应第一行，一维数组，对应的通过指针来取这个数组，它对应的指针就是a+0，那么这个数组就是*(a+0)
//    a[1] :对应第二行，一维数组，对应的通过指针来取这个数组，它对应的指针就是a+1，那么这个数组就是*(a+1)
//    a[2] :对应第三行，一维数组，对应的通过指针来取这个数组，它对应的指针就是a+2，那么这个数组就是*(a+2)
//    a[0][0]:对应第一行第一个元素，即数组*(a+0)的第0元素，它对应指针就是*(a+0)+0，通过指针取值就是*(*(a+0)+0)
//    a[0][1]:对应第一行第二个元素，即数组*(a+0)的第1元素，它对应指针就是*(a+0)+1，通过指针取值就是*(*(a+0)+1)
//    a[0][2]:对应第一行第三个元素，即数组*(a+0)的第2元素，它对应指针就是*(a+0)+2，通过指针取值就是*(*(a+0)+2)
//    a[1][0]:对应第二行第一个元素，即数组*(a+0)的第0元素，它对应指针就是*(a+1)+0，通过指针取值就是*(*(a+1)+0)
//    a[1][1]:对应第二行第二个元素，即数组*(a+0)的第1元素，它对应指针就是*(a+1)+1，通过指针取值就是*(*(a+1)+1)
//    a[1][2]:对应第二行第三个元素，即数组*(a+0)的第2元素，它对应指针就是*(a+1)+2，通过指针取值就是*(*(a+1)+2)
    
    
    for (int i = 0; i < 3; i ++) {
        for (int j = 0; j < 4; j ++) {
            printf("%d ",*(*(a + i) +j));
            //*(a + i) 取第i行数组，即第i行数组的首元素地址
        }
        printf("\n");
    }
    printf("\n");
    
    for (int i = 0; i < 3; i ++) {
        for (int j = 0; j < 4; j ++) {
            printf("%d ",a[i][j]);
        }
        printf("\n");
    }
}

打印结果：
1 2 3 4 
5 6 7 8 
11 22 33 44 

1 2 3 4 
5 6 7 8 
11 22 33 44 

指向多维数组元素的指针变量：

int a[3][4] = {{1,2,3,4},{5,6,7,8},{11,22,33,44}};
int *p;
for (p = a[0]; p < a[0]+12; p ++) {
    if ((p-a[0]) % 4 == 0) {
        printf("\n");
    }
    printf("%d ",*p);
}

打印结果：
1 2 3 4 
5 6 7 8 
11 22 33 44 

四、指针与字符串

字符串是一个字符类型的数组，C语言中没有字符串变量。

引用字符串两种方式

1、 用字符串数组存放一个字符串，可以通过数组名和下标引用字符串中一个字符，也可以通过数组名和格式声明%s输出该字符串

2、用字符指针变量指向一个字符串常量，通过字符指针变量引用字符串常量。对字符指针变量初始化，实际上是吧字符串第一个元素的地址(即存放字符串的字符数组的首元素地址)赋给指针变量，是指针变量指向字符串的第一个字符。

char string[] = "I Love C";
printf("%s\n",string);
printf("%c\n",string[7]);
    
char *pString = "I Love C";
printf("%s\n",pString);

• 字符数组最后一个元素为'\0'，因此通过\s输出是能确定输出到什么位置结束。

char *pString = "I Love C";
printf("%s\n",pString);
    
for (int i = 0;  *(pString + i) != '\0'; i ++) {
    printf("%c",*(pString + i));
}

使用字符指针变量和字符数组的比较

• 1、字符数组由若干个元素主城，每个元素中存放一个字符，二字符指针变量中存放的是地址(字符串第一个字符的地址)，绝不是将字符串存放到字符指针变量中。
• 2、赋值方式，可以对字符指针变量赋值，但不能对数组名赋值

可以采用以下方法对字符指针变量赋值：

char *pString2 ;
pString2 = "Test";
printf("%s\n",pString2);

不能以下面方法对字符串数组名赋值：(数组名是地址，是常量，是首元素地址，不能赋予具体字符值)

char str[4];
str[0] = 'A';//对数组元素赋值，合法
str = "Test";//数组名是地址，是常量，不能被赋值。非法

• 3、初始化的含义，对字符指针变量赋初值

char *pString2 = "Test" ; //定义字符串指针变量，并把字符串第一个元素地址赋给pString2.

//等价于
char *pString2; //定义支付串指针变量
pString2 = "Test"; //把字符串第一个元素的地址赋给pString2
    
char str[14] = "Test" ;//定义字符数组str，并把字符串赋值给数组中各元素。

//不等价于
char str[14]; //定义字符数组str
str = "Test";//企图把字符串赋值给数组中各元素
    

这个问题可以回顾字符串数组的初始化方式

• 4、 存储单元内容，编译时为字符串数组分配若干存储单元，以存放各元素的值，而对字符指针变狼，只分配一个存储单元。

如果定义一个字符数组，但未对它赋值，这是数组中的元素的值是不可预料的，可以引用这些值，结果无意义，但不会造成严重后果。

如果定义字符指针变量，应当及时把一个字符串变量地址赋给它，是他指向一个字符型数据。如果未对它赋予一个地址值，他并未具体指向一个确定的对象。此时如果引用该指针变量所指向的对象，可以会出现严重后果。应当在定义指针变量后，及时指定其指向。

• 5、指针变量的值是可以改变的，但数组名代表一个固定的值，不能改变。
• 6、字符串数组中各元素的值是可以改变的(可以对它们再赋值)，但字符串指针变量指向的字符串常量中的内容是不可以被取代的(不能再赋值)

char string[] = "I Love C";
string[2] = 'M'; //可以对数组元素再赋值
printf("%s\n",string);

char *pString2 ;
pString2 = "Test";
pString2[1] = 'P'; //非法，字符串常量不能改变，报错。

• 7、引用数组元素。对字符数组可以用下标法引用一个数组元素(如a[2])，也可以用地址法(如*(a+2))。如果定义了字符指针变量p。并使它指向数组a首元素地址，则可以用指针变量带下标的形式引用数组元素(如p[2])，也可以使用地址法引用(如*(a+2))

五、函数指针

函数指针：编译系统为函数代码分配一段存储空间，这段存储空间的起始地址(入口地址)成为这个函数的指针。

1、定义

定义指向函数的指针变量的一边形式:类型名 (* 指针变量名)(函数参数列表)
类型名是函数返回值类型，函数参数列表是函数本身的参数列表

例如：int (*p)(int ,int)，定义p是一个指向函数的指针变量，p的类型用int (*)(int ,int)表示。

2、使用函数指针调用函数

直接用函数指针名(或(*p))代替函数名，直接调用函数。

int max(int a,int b) {
    int z = a;
    if (a < b) {
        z = b;
    }
    return z;
}
int main(int argc, const char * argv[]) {
    
    int a = 19,b=23;
    int (*p)(int ,int) = max; //定义指针变量
    printf(%d \n),max(a,b));//函数名调用函数
    int c = p(a,b); //直接用函数指针代替函数名，调用函数
    //或者用(*p)代替函数名 c = (*p)(a,b);
    
    p = min; //重新赋值新的函数指针
    int d = p (a,b);
    printf("较大值：%d \n 较小值：%d\n",c,d);    
    return 0;
}

• 1、定义指向函数的指针变量，只能指向在定义时指定的类型的函数。
• 2、如果要用指针变量调用函数，必须先使指针指向该函数，将函数入口地址赋值给指针扁平
• 3、给函数指针变量赋值时，秩序给出函数名，而不需要给参数，如p = max;而不能用p=max(a,b);后者是将函数返回值赋给p，是错误的。
• 4、指向函数的指针变量，不能进行算术运算，没有意义。不同于一般的指针变量。
• 5、用函数名调用函数，只能调用所指定的一个函数，而通过指针变量调用函数比较灵活，可以根据不同情况先后调用不同的函数。即给指针变量重新赋值，前提是函数类型相同

3、指向函数的指针作为函数参数

指向函数的指针变量的一个重要用途是把函数的地址作为参数传递到其他函数。把函数入口地址传递给形参，就能够在被调用的函数中使用实参函数。

int max(int a,int b) {
    int z = a;
    if (a < b) {
        z = b;
    }
    printf("max: ");
    return z;
}
int min(int a,int b) {
    int z = a;
    if (a > b) {
        z = b;
    }
    printf("min: ");
    return z;
}

int sum(int a,int b) {
    printf("sum: ");
    return a + b;
}

int fun(int a,int b,int (*p)(int,int)) {
    return p (a,b);
}

int main(int argc, const char * argv[]) {
    
    int a = 100,b = 20;
    
    int c;
    printf("0-max,1-min,2-sum:");
    scanf("%d",&c);
    int result ;
    switch (c) {
        case 0:
            result = fun(a, b, max); //传入不同的函数首地址
            break;
        case 1:
            result = fun(a, b, min);
            break;
        case 2:
            result = fun(a, b, sum);
            break;
        default:
            result = 0;
            break;
    }
    
    printf("%d \n",result);
    return 0;
}

4、返回指针值的函数

指针也是一种变量类型，可以作为返回值。如int * fun(int a,int b);调用之后能得到一个int *类型的指针。

• 定义返回指针值的形式：类型名 * 函数名(参数类型)

//查看指定编号用户成绩
float *search(float (* point)[4] ,int number) {
    //形参point指向一维数组的指针变量，但其代表的是二维数组的首地址
    //float (* point)[4]
    float *pt ;
    pt = *(point + number);
    return pt;
}

//判断学生是否有不及格的成绩，如果有打印所有成绩
float * search_low (float(* point)[4] ) {
    //形参point指向一维数组的指针变量，二维数组中每一行的一维数组的首地址
    float *pt = NULL;
    
    for (int i = 0; i < 4; i ++) {
        float  s =  *(*point + i);//*point + i 一维数组地i个元素的地址
        if (s < 60) {
            pt = *point;
        }
    }
    return pt;
}

int main(int argc, const char * argv[]) {
    
    float score[][4] = {{67,68,78,98},{58,90,65,80},{40,80,78,67}};
    //二维数组，每一行代表一个学生，四列代表四科成绩。
    //
    float *p ;
    
    for (int i = 0; i < 3; i ++) {
        p = search_low(score+i);//遍历每一行/每个学生
        if (p == *(score+i)) { //判断不为空，判断是否为对应行首地址
            printf("Number :%d score:",i);
            for (int j = 0; j < 4; j ++) {
                printf("%5.2f ", *(p + j));
            }
            printf("\n");
        }
    }
    
    
    int number;
    printf("input student number: ");
    scanf("%d",&number);

    p = search(score, number);
    //score地址即首元素地址，首元素是一个float类型长度为4的一维数组
    for (int i = 0; i < 4; i ++) {
        printf("%.2f ",*(p+i));
    }
    printf("\n");
    
    return 0;
}

打印结果：
Number :1 score:58.00 90.00 65.00 80.00 
Number :2 score:40.00 80.00 78.00 67.00 
input student number: 1
58.00 90.00 65.00 80.00 

六、指针数组和多重指针

1、指针数组

指针数组：所有元素均为指针类型数据的数组，称为指针数组。

• 一般定义式：类型名 * 数组名[数组长度]

int *p[4]，因为[]比*优先级高，因此p先于[4]结合，形成p[4]，这就是数组形式，p有四个元素。然后再与*结合，表示此数组是指针类型的，每一个元素都可指向一个整型变量。

注 ：不能写成 int (*p)[4],这是指向一维数组的指针变量。

七、指针变量的类型及含义

指针变量类型及含义.png