开讲啦：Chap 08 善于利用指针

最新推荐文章于 2023-03-24 23:56:18 发布
最新推荐文章于 2023-03-24 23:56:18 发布
阅读量270 收藏
点赞数
文章标签： 数据结构 c语言 计算机考研
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_41767802/article/details/120644326
版权
本文深入讲解了C语言中指针的概念、直接访问与间接访问，以及指针变量的使用，包括作为函数参数传递、数组操作、字符串引用和动态内存分配。通过实例演示，理解指针如何操作变量、数组和函数，以及在实际编程中的关键应用。
摘要由CSDN通过智能技术生成

前言

不掌握指针就是没有掌握C的精华。

8.1 指针是什么

1. 概念

如果在程序中定义了一个变量，在对程序进行编译时，系统就会给这个变量分配内存单元，编译系统根据程序中定义的变量类型，分配一定长度的空间，内存区的每一个字节有一个编号，这就是地址，它相当于旅馆中的房间号，在地址所标志的内存单元中存放的数据则相当于旅馆房间中居住的旅客。我们将地址形象化为指针，即通过它能找到以它为地址的内存单元。

对于如下语句：

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

在程序中一般是通过变量名来引用变量的值，实际上是通过变量名i找到存储单元的地址，从而对存储单元进行存取操作的，程序经过编译以后已经将变量名转换为变量的地址，对变量值的存取都是通过地址进行的。

对于如下语句：

scanf("%d",&i);

程序执行时，是将键盘输入的值送到地址为2000开始的整型存储单元中。

2. 直接访问与间接访问

打个比方，为了开一个抽屉A，有两种办法，一种是将A钥匙带在身上，需要时直接找出该钥匙打开抽屉，取出所需的东西；另一种办法是：为了安全起见，将该A钥匙放到另一抽屉B中锁起来，如果需要打开A抽屉，就需要找出B钥匙，打开B抽屉，取出A钥匙，再打开A抽屉，即可取出取出A抽屉中的东西，这就是间接访问。

723a5a9a9d23b62f68fdac6807714ad8.png

如果需要将数值3送到变量中去，可以有两种方法：

  • 将3直接送到变量i所标志的单元中，如i=3，如图a所示；

  • 将3送到变量i_pointer所指向的单元，即变量i的存储单元，如*i_pointer=3，其中*i_pointer表示i_pointer指向的对象；

指针是一个地址，而指针变量是存放地址的变量。

8.2 指针变量

存放地址的变量是指针变量，它用来指向另一个对象，如变量、数组、函数等。

8.2.1 使用指针变量的例子

例8.1 通过指针变量访问整型变量

#include<stdio.h>
int main(){
    int a = 100,b = 10;
    int *pointer_1,*pointer_2;
    pointer_1 = &a;
    pointer_2 = &b;
    printf("a = %d,b = %d\n",a,b);
    printf("*pointer_1 = %d,*pointer_2 = %d\n",*pointer_1,*pointer_2);
    printf("addr_a = %x,addr_b = %x\n",&a,&b);
    return 0;
}

请看演示效果：

2563855f9da4b8756780033c89fa54e3.png

8.2.2 怎样定义指针变量

定义指针变量的一般形式为：类型名 *指针变量名，如int *pointer_1,*pointer_2，其中int表示在定义指针变量时必须指定的基类型，指针变量是基本数据类型派生出来的类型，它不能离开基本类型而独立存在。

一个变量的指针的含义包含两个方面，一方面是以存储单元编号表示的地址（如编号为2000的字节），另一方面是它指向的存储单元的数据类型，如int、char、float等，在说明变量类型时不能一般地说a是一个变量，而应完整地说a是指向整型数据的指针变量，b是指向单精度型数据的指针变量，c是指向字符型数据的指针变量。

8.2.3 怎样引用指针变量

在引用指针变量时，可能有3种情况：

  • 给指针变量赋值，如p=&a;，即将a的地址赋给指针变量p，此时指针变量p的值是变量a的地址，p指向a；

  • 引用指针变量指向的变量，如果已执行p=&a;，即指针变量p指向了整型变量a，则printf("%d",*p);的作用是以整数形式输出指针变量p所指向的变量的值，即变量a的值，如有以下赋值语句*p=1；表示将整数1赋给当前所指向的变量，如果p指向变量a，则相当于把1赋给a，即a=1;；

  • 引用指针变量的值，如printf("%o",p);作用是以八进制数形式输出指针变量p的值，如果p指向了a，就是输出了a的地址，即&a；

例8.2 输入a和b两个整数，按先大后小的顺序输出a和b，要求不交换整型变量的值，而是交换两个指针变量的值。

#include<stdio.h>
int main(){
    int *p1,*p2,*p,a,b;
    printf("请输入两个整数：");
    scanf("%d %d",&a,&b);
    p1 = &a;
    p2 = &b;
    if(a<b){
        p  = p1;
        p1 = p2;
        p2 = p;
    }
    printf("a = %d,b = %d\n",a,b);
    printf("max = %d,min = %d\n",*p1,*p2);
    return 0;
}

请看演示效果：

2c0b0f968b23c4ee16f503583d5da788.png

8.2.4 指针变量作为函数参数

函数的参数不仅仅可以是整型、浮点型、字符型等数据，还可以是指针类型，它的作用是将一个变量的地址传送到另一个函数中。

单向传递的值传递方式，形参值的改变不能使实参的值随之改变，因此为了使函数中改变了的变量值能被主调函数main所用，不能采取将要改变的变量值作为参数的方法，而应该用指针变量作为函数参数，在函数执行过程中使指针变量所指向的变量值发生变化，函数调用结束后，这些变量值的变化依然保留下来，这样就实现了通过调用函数使变量的值发生变化，在主调函数中可以使用这些改变了的值的目的。

例8.3 对输入的两个整数按大小顺序输出，要求通过函数处理，并且用指针类型的数据作为函数参数。

#include<stdio.h>
int main(){
    void swap(int *p1,int *p2);
    int a,b;
    int *pointer_1,*pointer_2;
    printf("请输入两个整数：");
    scanf("%d %d",&a,&b);
    pointer_1 = &a;
    pointer_2 = &b;
    if(a<b){
        swap(pointer_1, pointer_2);
    }
    printf("a = %d,b = %d\n",a,b);
    printf("max = %d,min = %d\n",*pointer_1,*pointer_2);
    return 0;
}
void swap(int *p1,int *p2){
    int temp;
    temp = *p1;
    *p1 = *p2;
    *p2 = temp;
}

请看运行效果：

25e335bfbbd0704c4d99b147acf7892b.png

C语言中实参变量和形参变量之间的数据传递是单向的值传递方式，用指针变量作函数参数时同样要遵循这一规则，不可能通过执行调用函数来改变实参指针变量的值，但是可以改变实参指针变量所指变量的值。

例8.4 输入3个整数a、b、c，要求按由大到小的顺序将它们输出。

#include<stdio.h>
int main(){
    void exchange(int *p1,int *p2,int *p3);
    int a,b,c,*p1,*p2,*p3;
    printf("请输入三个整数：");
    scanf("%d %d %d",&a,&b,&c);
    p1 = &a;
    p2 = &b;
    p3 = &c;
    exchange(p1, p2, p3);
    printf("由大到小的顺序为:%d,%d,%d\n",a,b,c);
    return 0;
}
void exchange(int *p1,int *p2,int *p3){
    void swap(int *q1,int *q2);
    if(*p1 < *p2){
        swap(p1, p2);
    };
    if (*p1 < *p3){
        swap(p1, p3);
    };
    if(*p2 < *p3){
        swap(p2, p3);
    }
}
void swap(int *q1,int *q2){
    int temp;
    temp = *q1;
    *q1 = *q2;
    *q2 = temp;
}

请看演示效果：

757a24d810a064a2c567c1099585ff0e.png

8.3 通过指针引用数组

8.3.1 数组元素的指针

所谓数组元素的指针就是数组元素的地址，在C语言中，数组名代表数组中首元素的地址，因此，存在以下等价语句：

int *p = &a[0];
int *p = a[0];

8.3.2 在引用数组元素时指针的运算

在指针指向数组元素时，可以对指针进行以下运算：

  • 加一个整数（用+或+=），如p + 1；

  • 减一个整数（用-或-=），如p - 1；

  • 自加运算，如p++、++p；

  • 自减运算，如p--，--p；

以上四种指针运算，系统会根据p的基类型来移动指针的位置。

cb722922e0aeba099072fba68fef592e.png

  • 如果两个指针变量p1和p2都指向同一数组，如执行p1-p2，结果是p2-p1的值除以数组元素的长度。

8.3.3 通过指针引用数组元素

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

  • 下标法：如a[i]形式；

  • 指针法：如*(a+i)或*(p+i)，其中a是数组名，p是指向数组元素的指针变量；

例8.5 输出数组中的全部元素。

  • 下标法

#include<stdio.h>
int main(){
    int arr[10];
    printf("请输入数组元素：");
    for (int i = 0; i < 10; i++) {
        scanf("%d",&arr[i]);
    }
    printf("数组元素分别为：");
    for (int i = 0; i < 10; i++) {
        printf("%3d",arr[i]);
    }
    printf("\n");
    return 0;
}

  • 通过数组名计算数组元素地址，找出元素的值

#include<stdio.h>
int main(){
    int arr[10];
    printf("请输入数组元素：");
    for (int i = 0; i < 10; i++) {
        scanf("%d",arr+i);
    }
    printf("数组元素分别为：");
    for (int i = 0; i < 10; i++) {
        printf("%3d",*(arr+i));
    }
    printf("\n");
    return 0;
}

  • 用指针变量指向数组元素

#include<stdio.h>
int main(){
    int arr[10],*p;
    printf("请输入数组元素：");
    for (int i = 0; i < 10; i++) {
        scanf("%d",arr+i);
    }
    printf("数组元素分别为：");
    for (p = arr;p < (arr+10); p++) {
        printf("%3d",*p);
    }
    printf("\n");
    return 0;
}

C编译系统是将arr[i]转换为*(arr+i)处理的，即先计算元素地址，因此前两种方法相比第三种方法，较为耗时。

如果p当前指向a数组中第i个元素a[i]，则：

  • *(p--)相当于a[i--]，即先对p进行*运算，在执行自减操作；

  • *(++p)相当于a[++i]，即先对p执行自加操作，在进行*运算；

#include<stdio.h>
int main(){
    int arr[10] = {0,1,2,3,4,5,6,7,8,9},*p;
    p = arr;
    printf("*(p++) = %d\n",*(p++));
    p = arr;
    printf("*(++p) = %d\n",*(++p));
    p = arr;
    printf("++(*p) = %d\n",++(*p));
    return 0;
}

请看运行效果：

9e6ee24689c47ed94a18b4e13c4e9236.png

8.3.4 用数组名作函数参数

例8.6 将数组中的元素逆序存放

#include<stdio.h>
int main(){
    void inverse(int arr[],int n);
    int i,arr[10]  = {0,1,2,3,4,5,6,7,8,9};
    printf("原始数组为：\n");
    for (i = 0; i < 10; i++) {
        printf("%3d",arr[i]);
    }
    printf("\n");
    inverse(arr, 10);
    printf("逆序之后的数组为：\n");
    for (i = 0; i < 10; i++) {
        printf("%3d",arr[i]);
    }
    printf("\n");
    return 0;
}
void inverse(int *arr,int n){
    int *p,temp,*i,*j,m = (n-1)/2;
    i = arr;
    j = arr+n-1;
    p = arr+m;
    for (; i <= p; i++,j--) {
        temp = *i;
        *i = *j;
        *j = temp;
    }
}

如果有一个实参数组，要想在函数中改变此数组中的元素的值，实参与形参的对应关系有以下4种情况：

  • 形参和实参都用数组名；

93bf75d833bcc3e38fe0e4989b31b44b.png

  • 实参用数组名，形参用指针变量；

  • 实参形参都用指针变量；

5ad3c62657811e4d8c1d9792a36e4574.png

  • 实参为指针变量，形参为数组名；

9c228e9c48986853050dc42fc69a8cb2.png

用指针变量作实参：

#include<stdio.h>
int main(){
    void inverse(int *arr,int n);
    int i,arr[10]  = {0,1,2,3,4,5,6,7,8,9},*p = arr;
    printf("原始数组为：\n");
    for (i = 0; i < 10; i++,p++) {
        printf("%3d",*p);
    }
    printf("\n");
    p = arr;
    inverse(p, 10);
    printf("逆序之后的数组为：\n");
    for (p = arr;p < arr+10; p++) {
        printf("%3d",*p);
    }
    printf("\n");

    return 0;
}
void inverse(int *arr,int n){
    int *p,m,temp,*i,*j;
    m = (n-1)/2;
    i = arr;
    j = arr+n-1;
    p  = arr+m;
    for (;i <= p ; i++,j--) {
        temp = *i;
        *i = *j;
        *j = temp;
    }
}

例8.7 用指针方法对10个整数按由大到小的顺序排序。

#include<stdio.h>
int main(){
    void sort(int arr[],int n);
    int *p,arr[10];
    p = arr;
    printf("请输入数组元素：");
    for (int i = 0; i < 10; i++) {
        scanf("%d",p++);
    }
    p = arr;
    sort(p, 10);
    printf("由大到小的顺序为：\n");
    for (p = arr; p < (arr+10); p++) {
        printf("%3d",*p);
    }
    printf("\n");
    return 0;
}
void sort(int *arr,int n){
    int i,j,k,t;
    for (i = 0; i < n-1; i++) {
        k = i;
        for (j = k+1; j < n; j++) {
            if(*(arr+j)>*(arr+k)){
                k = j;
            }
        }
        if(k!=i){
            t = arr[i];
            arr[i] = arr[k];
            arr[k] = t;
        }
    }
}

8.3.5 通过指针运用多维数组

1. 多维数组元素的地址

int arr[3][4] = {
	{1,3,5,7},
	{9,11,13,15},
	{17,19,21,23}
}

从二维数组的角度来看，arr表示二维数组首元素的地址，现在的首元素不是一个简单的整型元素，而是由4个整型元素组成的一维数组，因此arr代表的是首行的首地址，arr+1代表序号为1的行的首地址，如果二维数组的首行的首地址为2000，一个整型数据占4个字节，则a+1的值应该是2000+4*4=2016，arr+1指向arr[1]，或者说arr+1的值是arr[1]的首地址，arr+2代表arr[2]的首地址。

arr[0]、arr[1]、arr[2]既然是一维数组名，而C语言又规定了数组名代表数组首元素地址，因此arr[0]代表一维数组arr[0]中第0列元素的地址，即&a[0][0]，也就是说arr[1]的值是&arr[1][0]，arr[2]的值是&arr[2][0]。

bf76cf8fa210075798e19349d63295a4.png

例8.8 输出二维数组的有关数据。

#include<stdio.h>
int main(){
    int arr[3][4] = {1,2,3,4,5,6,7,8,9,10,11,12};
    printf("%d %d\n",arr,*arr);
    printf("%d %d\n",arr[0],*(arr+0));
    printf("%d %d\n",&arr[0],&arr[0][0]);
    printf("%d %d\n",arr[1],arr+1);
    printf("%d %d\n",&arr[1][0],*(arr+1)+0);
    printf("%d %d\n",arr[2],*(arr+2));
    printf("%d %d\n",&arr[2],arr+2);
    printf("%d %d\n",arr[1][0],*(*(arr+1)+0));
    printf("%d %d\n",*arr[2],*(*(arr+2)+0));
    return 0;
}

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

  • 指向数组元素的指针变量

例8.9 使用指针元素输出二维数组元素值。

#include<stdio.h>
int main(){
    int arr[3][4] = {1,2,3,4,5,6,7,8,9,10,11,12};
    int *p;
    for (p = arr[0]; p < arr[0]+12; p++) {
        if((p-arr[0])%4==0){
            printf("\n");
        }
        printf("%3d",*p);
    }
    printf("\n");
    return 0;
}

  • 指向由m个元素组成的一维数组的指针变量

例8.10 输出二维数组特定行和列的元素值。

#include<stdio.h>
int main(){
    int arr[3][4] = {1,2,3,4,5,6,7,8,9,10,11,12};
  	//(*p)[4]表示定义p为一个指针变量，它指向包含4个整型元素的一维数组。
    int *pointer,(*p)[4],i,j;
    printf("原数组如下所示：\n");
    for (pointer = arr[0]; pointer < arr[0]+12; pointer++) {
        if((pointer-arr[0])%4==0){
            printf("\n");
        }
        printf("%3d",*pointer);
    }
    printf("\n");
    p = arr;
    printf("请输入行和列：");
    scanf("%d %d",&i,&j);
    printf("arr[%d][%d]=%d\n",i,j,*(*(p+i)+j));
    return 0;
}

3. 用指向数组的指针作函数参数

例8.11 计算3个学生（每个学生4门课）的总平均分以及第n个学生的成绩。

#include<stdio.h>
int main(){
    void average(float *p,int n);
    void search(float (*p)[4],int n);
    float score[3][4] = {
        {78,67,89,78},
        {34,67,54,90},
        {89,90,67,89}
    };
    average(*score, 12);
    search(score, 2);
    return 0;
}

void average(float *p,int n){
    float sum = 0,aver;
    float *p_end = p+n-1;
    for (; p <= p_end; p++) {
        sum += (*p);
    }
    aver = sum / n;
    printf("aver=%5.2f\n",aver);
}
void search(float (*p)[4],int n){
    printf("第%d个学生成绩为:",n);
    for (int i = 0; i < 4; i++) {
        printf("%10.2f",*(*(p+n)+i));
    }
    printf("\n");
}

例8.12 在例8.11的基础上找出有一门以上课程不及格的学生，并输出全部课程的成绩

#include<stdio.h>
int main(){
    void search(float (*p)[4],int n);
    float score[3][4] = {
        {78,67,89,78},
        {34,67,54,90},
        {89,90,67,89}
    };
    search(score, 3);
    return 0;
}

void search(float (*p)[4],int n){
    int i,j,flag;
    for (i = 0; i < n; i++) {
        flag = 0;
        for (j = 0; j < 4; j++) {
            if(*(*(p+i)+j) < 60){
                flag = 1;
            }
        }
        if(flag == 1){
            printf("第%d个学生成绩不合格,其各科成绩如下：\n",(i+1));
            for (j = 0; j < 4; j++) {
                printf("%10.2f",*(*(p+i)+j));
            }
            printf("\n");
        }
    }
}

8.4 通过指针引用字符串

8.4.1 字符串的引用方式

在C程序中，要想引用一个字符串，可以有以下两种方法：

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

#include<stdio.h>
int main(){
    char string[] = "I am hahaCoder!";
    printf("%s\n",string);
    printf("%c\n",string[7]);
    return 0;
}

  • 用字符指针变量指向一个字符串常量，通过字符指针变量引用字符串常量；

#include<stdio.h>
int main(){
    char *string = "I am hahaCoder!";
    printf("%s\n",string);
    return 0;
}

对字符指针变量string初始化，实际上是把字符串第1个元素的地址（即存放字符串的字符数组的首元素地址）赋给指针变量string，使string指向字符串的第1个字符，在输出项中给出字符指针变量名string，则系统会输出string所指向的字符串第1个字符，然后自动使string加1，使之指向下一个字符，在输出字符......如此直到遇到字符串结束标志\0为止。

「注」：通过字符数组名或字符指针变量可以输出一个字符串，而对一个数值型数组，是不能企图用数组名输出它的全部元素的。

例8.13 将字符串a复制为字符串b，然后输出字符串b。

  • 地址法

#include<stdio.h>
int main(){
    char arr[] = "I am hahaCoder!",arr_cpy[20];
    int i;
    for (i = 0; *(arr+i)!='\0'; i++) {
        *(arr_cpy+i) = *(arr+i);
    }
    *(arr_cpy+i) = '\0';
    printf("字符串arr为：%s\n",arr);
    printf("字符串arr_cpy为:%s\n",arr_cpy);
    return 0;
}

  • 指针变量法

#include<stdio.h>
int main(){
    char arr[] = "I am hahaCoder!",arr_cpy[20],*p_arr,*p_arrCpy;
    p_arr = arr;
    p_arrCpy = arr_cpy;
    for (; *p_arr!='\0'; p_arr++,p_arrCpy++) {
        *p_arrCpy = *p_arr;
    }
    *p_arrCpy = '\0';
    printf("字符串arr为：%s\n",arr);
    printf("字符串arr_cpy为:%s\n",arr_cpy);
    return 0;
}

8.4.2 字符指针作函数参数

例8.14 用函数调用实现字符串的复制。

  • 用字符数组名作为函数参数

#include<stdio.h>
int main(){
    void cpy_string(char source[],char dest[]);
    char arr_source[] = "I am hahaCoder!";
    char arr_dest[] = "www.shipudong.com!";
    printf("arr_source=%s\narr_dest=%s\n",arr_source,arr_dest);
    printf("将字符串arr_source复制给arr_dest:\n");
    cpy_string(arr_source, arr_dest);
    printf("arr_source=%s\narr_dest=%s\n",arr_source,arr_dest);
    return 0;
}
void cpy_string(char source[],char dest[]){
    int i = 0;
    while (source[i]!='\0') {
        dest[i] = source[i];
        i++;
    }
    dest[i] = '\0';
}

  • 用字符指针变量作实参

#include<stdio.h>
int main(){
    void cpy_string(char source[],char dest[]);
    char arr_source[] = "I am hahaCoder!";
    char arr_dest[] = "www.shipudong.com!";
    char *source = arr_source,*dest = arr_dest;
    printf("arr_source=%s\narr_dest=%s\n",arr_source,arr_dest);
    printf("将字符串arr_source复制给arr_dest:\n");
    cpy_string(source, dest);
    printf("arr_source=%s\narr_dest=%s\n",arr_source,arr_dest);
    return 0;
}
void cpy_string(char source[],char dest[]){
    int i = 0;
    while (source[i]!='\0') {
        dest[i] = source[i];
        i++;
    }
    dest[i] = '\0';
}

  • 用字符指针变量作实参和形参

#include<stdio.h>
int main(){
    void cpy_string(char source[],char dest[]);
    char *arr_source = "I am hahaCoder!";
    char arr_dest[] = "www.shipudong.com!";
    char *dest = arr_dest;
    printf("arr_source=%s\narr_dest=%s\n",arr_source,arr_dest);
    printf("将字符串arr_source复制给arr_dest:\n");
    cpy_string(arr_source, dest);
    printf("arr_source=%s\narr_dest=%s\n",arr_source,arr_dest);
    return 0;
}
void cpy_string(char *source,char *dest){
    for (; *source!='\0'; source++,dest++) {
        *dest = *source;
    }
    *dest = '\0';
}

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

  • 字符数组由若干个元素组成，每个元素中放一个字符，而字符指针变量中存放的是字符串第1个字符的地址；

  • 可以对字符指针变量赋值，但不能对数组名赋值；

  • 编译时为字符数组分配若干存储单元，以存储各元素的值，而对字符指针变量，只分配一个存储单元；

  • 指针变量的值是可以改变的，而数组名代表一个固定的值，不能改变；

#include<stdio.h>
int main(){
    char *arr = "I love my motherland!";
    arr = arr+10;
    printf("%s\n",arr);
    return 0;
}

  • 字符数组中各元素的值是可以改变的，但字符指针变量指向的字符串常量中的内容是不可以被取代的；

  • 用指针变量指向一个格式字符串，可以用它代替printf函数中的格式字符串；

    • 指针变量

#include<stdio.h>
int main(){
    int a = 10;
    float b = 10.02;
    char *format = "a=%d,b=%.2f\n";
    printf(format,a,b);
    return 0;
}

    • 字符数组

#include<stdio.h>
int main(){
    int a = 10;
    float b = 10.02;
    char format[] = "a=%d,b=%.2f\n";
    printf(format,a,b);
    return 0;
}

8.5 指向函数的指针

8.5.1 什么是函数指针

如果在程序中定义了一个函数，在编译时，编译系统为函数代码分配一段存储空间，这段存储空间的起始地址称为这个函数的指针，可以定义一个指向函数的指针变量，用来存放某一函数的起始地址，这就意味着此指针变量指向该函数，如int (*p)(int,int)定义p是一个指向函数的指针变量，它指向一个整型函数，且具有两个整型参数。

8.5.2 用函数指针变量调用函数

调用函数的两种方法：

  • 函数名调用；

#include<stdio.h>
int main(){
    int max(int x,int y);
    int a,b,c;
    printf("请输入a、b的值：");
    scanf("%d %d",&a,&b);
    c = max(a,b);
    printf("a和b中的较大者为:%d\n",c);
    return 0;
}
int max(int x,int y){
    return x>y?x:y;
}

  • 指向函数的指针变量；

#include<stdio.h>
int main(){
    int max(int x,int y);
    int (*p)(int ,int);
    int a,b,c;
    p = max;
    printf("请输入a、b的值：");
    scanf("%d %d",&a,&b);
    c = (*p)(a,b);
    printf("a和b中的较大者为:%d\n",c);
    return 0;
}

int max(int x,int y){
    return x>y?x:y;
}

8.5.3 怎样定义和使用指向函数的指针变量

定义指向函数的指针变量的一般形式为：类型名 (*指针变量名)(函数参数列表)。

  • 对指向函数的指针变量不能进行算术运算；

  • 用函数名调用函数，只能调用所指定的一个函数，而通过指针变量调用函数比较灵活，可以根据不同情况先后调用不同的函数；

例8.15 用户根据数字编号选择不同的函数功能。

#include<stdio.h>
int main(){
    int max(int x,int y);
    int min(int x,int y);
    int (*p)(int ,int);
    int a,b,num;
    printf("请输入a、b的值：");
    scanf("%d %d",&a,&b);
    printf("请选择max(编号1)函数或min(编号2)函数：");
    scanf("%d",&num);
    if(num==1){
        p = max;
    }else if (num==2){
        p = min;
    }
    c = (*p)(a,b);
    if(num==1){
        printf("a和b中的较大者为:%d\n",c);
    }else{
        printf("a和b中的较小者为:%d\n",c);
    }
    return 0;
}

int max(int x,int y){
    return x>y?x:y;
}
int min(int x,int y){
    return x<y?x:y;
}

8.5.4 用指向函数的指针做函数参数

函数fun有两个形参x1和x2，定义x1和x2为指向函数的指针变量，在调用函数fun时，实参为两个函数名f1和f2，给形参传递的是函数f1和f2的入口地址，这样在函数fun中就可以调用f1和f2了。

例8.16 输入两个整数，完成max、min、add三个功能。

#include<stdio.h>
int main(){
    void fun(int x,int y,int (*p)(int,int));
    int max(int x,int y);
    int min(int x,int y);
    int add(int x,int y);
    int a,b,num;
    printf("请输入a、b的值：");
    scanf("%d %d",&a,&b);
    printf("请选择max(编号1)函数、min(编号2)函数或add(编号3)函数：");
    scanf("%d",&num);
    if(num==1){
        fun(a, b, max);
    }else if (num==2){
        fun(a, b, min);
    }else if(num==3){
        fun(a, b, add);
    }
    return 0;
}
void fun(int x,int y,int (*p)(int,int)){
    int result;
    result = (*p)(x,y);
    printf("result=%d\n",result);
}

int max(int x,int y){
    return x>y?x:y;
}
int min(int x,int y){
    return x<y?x:y;
}
int add(int x,int y){
    return x+y;
}

8.6 返回指针的函数

定义返回指针值的函数的一般形式为：类型名 *函数名(参数表列)。

例8.17 有a个学生，每个学生有b门课程的成绩，要求输入学生序号后，能输出该学生的全部成绩。

#include<stdio.h>
int main(){
    float score[][4] = {
        {78,86,95,67},
        {76,85,92,69},
        {57,81,92,69}
    };
    float *search(float (*pointer)[4],int n);
    float *p;
    int num;
    printf("请输入学生编号：");
    scanf("%d",&num);
    p = search(score, num);
    for (int i = 0; i < 4; i++) {
        printf("%5.2f\t",*(p+i));
    }
    printf("\n");
    return 0;
}

float *search(float (*pointer)[4],int n){
    return *(pointer+n);
}

例8.18 找出例8.17中不及格的学生。

#include<stdio.h>
int main(){
    float score[][4] = {
        {78,86,95,67},
        {76,85,92,69},
        {57,81,92,69}
    };
    float *search(float (*pointer)[4]);
    float *p;
    for (int i = 0; i < 3; i++) {
        p = search(score+i);
        if(p==*(score+i)){
            printf("第%d个学生成绩不合格。\n",i+1);
            for (int j = 0; j < 4;j++) {
                printf("%5.2f\t",*(p+j));
            }
            printf("\n");
        }
    }
    printf("\n");
    return 0;
}

float *search(float (*pointer)[4]){
    float *pt;
    pt = NULL;
    for (int i = 0; i < 4; i++) {
        if(*(*pointer+i) < 60){
            pt = *pointer;
        }
    }
    return pt;
}

8.7 指针数组和多重指针

8.7.1 什么是指针数组

定义一维指针数组的一般形式为：类型名 *数组名[数组长度]，指针数组比较适合用来指向若干个字符串，使字符串处理更佳方便灵活，如需将多个字符串存入一个数组中，并对其进行排序和查询操作，按照一般方法，字符串本身就是一个字符数组，因此要设计一个二维的字符数组才能存放多个字符串，但在定义二维数组时，需要指定列数，也就是说二维数组中每一行包含的元素个数相等，而实际上各字符串擦回归难度一般是不相等的，如按最长的字符串来定义列数，则会浪费许多内存单元。

因此，可以分别定义一些字符串，然后用指针数组中的元素分别指向各字符串，即指针数组中的元素分别存放各字符串首字符的地址，如果相对字符串排序，不必改动字符串的位置，只须改动指针数组中各元素的指向。

例8.19 将若干字符串按字母顺序由小到大输出。

#include<stdio.h>
#include<string.h>
int main(){
    void sort(char *name[],int n);
    void printStr(char *name[],int n);
    char *name[] = {"www.shipudong.com","hahaOCR","hahaCoder","hahaAI","hahaWebsite."};
    int n = 5;
    printf("原字符数组为:\n");
    printStr(name, n);
    printf("\n");
    sort(name, n);
    printf("排序之后的字符数组为:\n");
    printStr(name, n);
    printf("\n");
    return 0;
}
void sort(char *name[],int n){
    char *temp;
    int i,j,k;
    for (i = 0; i < n-1; i++) {
        k = i;
        for (j = i+1; j < n; j++) {
            if(strcmp(name[k], name[j])>0){
                k = j;
            }
        }
        if(k!=i){
            temp = name[i];
            name[i] = name[k];
            name[k] = temp;
        }
    }
}

void printStr(char *name[],int n){
    for (int i = 0; i < n; i++) {
        printf("%s\t",name[i]);
    }
}

8.7.2 指向指针数据的指针

可以设置一个指针变量p，使其指向指针数组，则变量p即为指向指针型数据的指针变量，定义形式为：char **p;等价于char *(*p)。

例8.20 使用指向指针数据的指针变量。

#include<stdio.h>
int main(){
    char *name[] = {"www.shipudong.com","hahaOCR","hahaCoder","hahaAI","hahaWebsite."};
    char **p;
    for (int i = 0; i < 5;i++) {
        p = name+i;
        printf("%s->%d\n",*p,*p);
    }
    return 0;
}

例8.21 使用指向指针数据的指针变量输出整型数组各元素的值。

#include<stdio.h>
int main(){
    int a[5] = {1,3,4,5,6};
    int *num[5] = {&a[0],&a[1],&a[2],&a[3],&a[4]};
    int **p;
    p = num;
    for (int i = 0; i < 5; i++,p++) {
        printf("地址:%d->元素值:%d\n",*p,**p);
    }
    return 0;
}

75ef379b02175986f34dc59e03834181.png

8.7.3 指针数组作main函数的形参

main函数的原型为：int main(int argc,char *argv[])，其中argc 即argument count表示参数个数，argv 即argument vector表示* char指针数组，数组中每一个元素指向命令行中的一个字符串。

8.8 动态内存分配与指向它的指针变量

8.8.1 什么是内存的动态分配

C语言允许建立内存动态分配区域，以存放一些临时用的数据，这些数据不必在程序的声明部分定义，也不必等到函数结束时才释放，而是需要时随时开辟，不需要时随时释放，这些数据是临时存放在一个特别的自由存储区，称为堆区，可以根据需要，向系统申请所需大小的空间，由于未在声明部分定义它们为变量或数组，因此不能通过变量名或数组名去引用这些数据，只能通过指针来引用。

8.8.2 怎样建立内存的动态分配

  • void *malloc(unsigned int size);

其作用是在内存的动态存储区中分配一个长度为size的连续空间，此函数是一个指针型函数，返回的指针指向该分配域的开头位置，如果此函数未能成功地执行，则返回空指针NULL。

  • void *calloc(unsigned n,unsigned size);

其作用是在内存的动态存储区中分配n个长度为size的连续空间，这个空间一般比较大，足以保存一个数组，函数返回指向所分配域的起始位置的指针，如果分配不成功，返回NULL。

  • void free(void *p);

其作用是释放指针变量p所指向的动态空间，使这部分空间能重新被其他变量使用，p应该是最近一次调用calloc或malloc函数时得到的函数返回值，free函数无返回值。

  • void *realloc(void *p,unsigned int size);

如果已经通过calloc或malloc函数获得了动态空间，想改变其大小，可以用realloc函数重新分配，用realloc函数将p所指向的动态空间的大小改变为size，p的值不变，如果重新分配不成功，返回NULL。

上述四个函数的声明均在stdlib.h头文件中。

8.8.3 void指针类型

例8.22 建立动态数组，存入学生成绩，并输出不合格的成绩。

#include<stdio.h>
#include<stdlib.h>
int main(){
    void check(int *p);
    int *p1 = (int *)malloc(5*sizeof(int));
    for (int i = 0; i < 5; i++) {
        printf("请输入第%d个学生成绩：",i+1);
        scanf("%d",p1+i);
    }
    printf("以下成绩不合格：\n");
    check(p1);
    return 0;
}
void check(int *p){
    for (int i = 0;i < 5; i++) {
        if(*(p+i)<60){
            printf("第%d个学生成绩为%d\n",i+1,*(p+i));
        }
    }
    printf("\n");
}

8.9 小节

b727cdb293d654ef0079567df60dbc92.png

课后题：1、2、3、8、9、15、18、19

hahaCoderX
关注
指针学习（4）
yooppa的博客
01-20 898
以往知识总结： 归纳起来，如果有一个实参数组，想在函数中改变此数组中的元素的值，实参与形参的对应关系有以下4种情况： 形参和实参都用数组名，如： void main() { int a[10]; f(a,10); } void f (int x[],int n) { … } 实参用数组名，形参用指针变量。如： void main() { int a[10]; f(a,10); } f (int *a,int n) { … } 实参形参都用指针变量。例如： void main() { int a[10],*
计算导论与程序设计：chap7 指针.ppt
05-20
计算导论与程序设计：chap7 指针.ppt
如何通过函数修改实参的值
GJG666的博客
11-07 4019
//例一：#include<stdio.h> void f(int **q); int main () { int i=9; int *p=&i; //相当于 int *p;p=&i; printf("%p\n",p);// %p是读取地址 f(&p);//p为 int*类型； printf ("%p\n",p); return 0; }void f(i
C语言之指针04
qq_42680327的博客
08-04 201
版权声明：本文为博主原创文章，未经博主允许不得转载。https://blog.csdn.net/qq_42680327 归纳起来，如果有一个实参数组，想在函数中改变数组中的元素的值，形参和实参对应关系有一下四种情况： (1)形参和实参都用数组名字,如: void main(){ int a[10]; f(a,10); } void f(int x[], int n){...
C语言中通过调用函数来修改实参值
我想月薪过万的博客
03-31 4621
问题阐述 在写C语言程序的时候啊，我们总会遇到这样一个问题，我们把参数传到函数里处理，一顿操作之后发现我们传进去的值并没有发生改变，这就有点令人头疼了。 问题原因 因为你传进去的是 值，此时，会发生值拷贝，你改变的那个参数已经不是你传进去的值了 代码复现 #include<stdio.h> #include<stdlib.h> void func(int copy_value){ copy_value = 100; } int main() { i
c语言猜宝游戏代码,u掌握指针与指针变量的概念.PDF
weixin_39778815的博客
05-23 207
第6章指针学习目标u 掌握指针与指针变量的概念u 了解指针与数组的关系，掌握如何使用指针引用数组中的数据u 了解指针与函数的关系，掌握如何通过指针调用函数u 掌握指针与二级指针的关系u 掌握内存的申请方法与操作方式指针是 C 语言中一种特殊的变量类型，与其它类型的变量不同，指针变量存储的不是变量，而是变量的地址。正确地使用指针，可以使程序更为简洁紧凑，高效灵活。指针是 C语言...
高级语言程序设计：chap06-指针初步.ppt
06-14
在高级语言程序设计中，指针是一个至关重要的概念，它允许程序员直接操作内存地址，从而实现更高效的数据处理和复杂的程序结构。本章主要讲解了指针的基本概念、使用指针访问数组元素以及字符指针的应用。 首先，...
高级语言程序设计：chap07_指针.ppt
09-17
高级语言程序设计：chap07_指针.ppt
数据库课件：chap08规范化.ppt
09-19
数据库课件：chap08规范化.ppt
高级语言程序设计：chap08-结构体相关.ppt
06-14
高级语言程序设计：chap08-结构体相关.ppt
数组指针（用几个例子来看看用法）
m0_53558236的博客
11-01 3394
这里的首元素就是二维数组arr的第一行的地址，第一行的地址，就是有5个整型元素的一维数组的地址，所以数组名就是二维数组第一行这个一维数组（1 2 3 4 5）的地址。我们要打印二维数组arr[3][5] = { 1,2,3,4,5, 2,3,4,5,6,3,4,5,6,7 }的内容。我们需要打印 arr[10] = {1,2,3,4,5,6,7,8,9,10}数组中的元素，有下面几个方法。一维数组的地址也是个数组的地址嘛，数组的地址就要存在数组指针里去。这个是指向一维数组的指针，而不是二维数组的。
指针与引用的例子
qq_41000080的博客
04-22 381
在Qt编程中，会经常使用指针、引用对变量进行传递与运算，总结一下。 指针是与数据相对应的，比起将整个数据进行传递而言，指针明显是更轻更快的； 例如对于二维数据的有关计算，个人习惯于用连续的一维数组进行表示： int main(){ void func(float *p,int m,int n); int m=100,n=50; float *p=(float *)malloc(siezof(float)*m*n); memset(p,0,size
C语言 通过指针引用数组元素
NuYoaH502329的博客
02-14 4040
引用一个数组元素有两种方法： （1）**下标法**，如a[i]的形式； （2）**指针法**，如`*(a+i)`或`*(p+i)`。其中a是数组名，p是指向数组元素的指针变量，其初值p=a。 【注意】 在使用指针变量指向数组元素时，要注意以下问题： （1）可以通过改变指针变量的值指向不同的元素。例如，当用指针变量p指向数组中的某一元素，用p++使p的值不断改变从而指向不同的元素。 如果不用p变化的方法而用数组名a变化的方法（例如，用a++）是不行的。因为数组名a代表数组首元素的地址，它是一个指针型常量，所以
【c++基础】6.内存机制、指针、引用、动态数组及实例
离光曦的博客
06-09 718
本章从c++的内存机制入手，首先介绍堆栈等内存机制，然后介绍指针、引用这两种核心的地址操作手段，最后介绍数组以及动态数组，在学习数组这种用户自定义类型的同时，加深对指针和内存机制的了解。【一】内存机制1、内存的概念内存可以将其简单理解为一个存数据的容器，内存中的数据在计算机关闭是将被清空。计算机中的内存一般是按照字节编址的，即一字节一地址，现在（2017-6）计算机的内存已经很大了，pc机最少也有4
C语言小例子【基础】
海到无边天作岸 山登绝顶我为峰
10-19 7396
1.Hello World 代码 #include <stdio.h> /* 包含标准输入输出头文件 */ void main() /* 主函数 */ { printf("Hello World!\n"); /* 打印输出信息 */ } 运行结果 2.两数之积 代码 #include <stdio.h> void main() { int x,y,m; /* 定义整型变量x，y，m */ printf("Please input x and y\
如何把一个数组的值赋给另一个数组
热门推荐
戴鑫的博客
09-22 1万+
java中的数组 一维数组中把一个数组的值赋给另外一个数组 import java.util.Arrays; public class test { public static void main(String[] args) { int[] arrays1= new int[] {1,2,3,4,5,78,45};//定义一个数组arrays1 int[] arrays2=...
C的实用笔记25——通过指针引用数组
最新发布
lzh201864031的博客
03-24 1705
不包括函数形参中的数组名。
指针数组案例学习
Leisure_ksj的博客
07-06 253
在介绍指针数组之前，首先必须先知道什么是数组，先来一个实例巩固下数组： #include <stdio.h> #include <stdlib.h> int main () { int i,Num, arr[100]; printf("请输入数组的长度(必须<100)："); scanf("%d",&Num); printf("数组个数为：%d\n",Num); for(i=0;i<Num;i++) { print
第八章(一)-----变量指针 及 数组指针
mlm5678的博客
03-26 362
1. 指针 ：指向某一类型变量的变量，所储存的值为它所指变量的地址，所以指针必须有机类型 指针拥有机类型，以便指针进行"+1","-1"的指向运算 2. * 与 & 3. 通过指针 引用数组 （1）通过指针，引用一维数组 例子： 下标法 #include <stdio.h> int main(){ int a[10]; for(int i=0;...
"高级语言程序设计：chap06-指针初步.ppt 寻找保险箱密码
在高级语言程序设计的第六章节中，我们学习了关于指针的基本概念和运用。指针是一种非常重要的数据类型，它可以用来存储变量的地址，从而可以实现对内存中存储的数据的直接访问和操作。在本章中，通过一个关于特工...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

hahaCoderX

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值