C语言笔记（十二）——二维指针（二）

àì夳堔傛蜴生んèń 2022-05-23 11:44 261阅读 0赞

## 1.1 指针数组 ##

int \*p \[5\];

<table style="width:200px;"> 
 <tbody> 
  <tr> 
   <td>定义</td> 
   <td>说明</td> 
  </tr> 
  <tr> 
   <td>int i;</td> 
   <td> <p>定义整型变量i</p> </td> 
  </tr> 
  <tr> 
   <td> <p>int *p;</p> </td> 
   <td>定义一个指向int的指针变量p</td> 
  </tr> 
  <tr> 
   <td>int a[10]</td> 
   <td>定义一个数组名为a的int数组</td> 
  </tr> 
  <tr> 
   <td>int *p[10]</td> 
   <td>定义一个<span style="color:#ff0000;">指针数组</span>，其中每个数组元素指向一个int型变量的地址</td> 
  </tr> 
  <tr> 
   <td>int (*p)[10]</td> 
   <td>定义一个<span style="color:#cc0000;">数组指针</span>，指向int[10]类型的指针变量</td> 
  </tr> 
  <tr> 
   <td>int dunc()</td> 
   <td>定义一个函数，返回值为int</td> 
  </tr> 
  <tr> 
   <td>int *func()</td> 
   <td>定义一个函数，返回值为int *型</td> 
  </tr> 
  <tr> 
   <td>int （*p）（）</td> 
   <td>定义一个指向函数的指针，函数的原型为无参数，返回值为int</td> 
  </tr> 
  <tr> 
   <td>int **p</td> 
   <td>定义一个指向int的指针的指针，即二级指针</td> 
  </tr> 
 </tbody> 
</table>

## ##

/*************指针数组和数组指针*****************/
    int main()
    {
        int *s[10] = { 0 }; //定义了一个数组
        int (*p)[10] = 0; //定义了一个指针变量，指向int 【10】这么大的一种数据类型
        sizeof(s) = 40;
        sizeof(p) = 4;
        
        return 0;
    }

### 1.1.1 指针数组 ###

int main()
    {
        int *p[3]; //定义了一个指针数组，有3个成员，每个成员都是int *
        int a = 1;
        int b = 2;
        int c = 3;
        p[0] = &a;
        p[1] = &b;
        p[2] = &c;
        *p[0] = 10; //通过指针数组成员访问指针指向内存的值
        printf("a = %d\n", a);
        return 0; 
    }

### 1.1.2 数组指针 ：大多数用于二维数组中 ###

int main ()
    {
        int(*p)[3];//定义了一个数组指针，是一个名字叫p的指针变量，他指向int[3]指针数据类型
        //数组指针大多数情况下用在指向一个二维数组。
        int buf1[5][3];
        int buf2[7][3];//只要二维数组的第一维是int[3]这种类型，那么都可以用int（*p）[3]来指向他
    }

数组指针（\*p）++；一次移动一整行。

指针数组\*p++；一次移动一位

int main ()
    {
        int buf[3][4] = { {1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12} };
        int(*p)[4];//定义了一个数组指针，是一个名字叫p的指针变量，他指向int[3]指针数据类型 //数组指针大多数情况下用在指向一个二维数组。
        p = buf;
     //p是连长 //*p是排长
       printf("%u, %u, %u, p = %u, *p = %u\n", buf, buf[0], &buf[0][0], p, *p);
       p++; //移动了4*sizeof（int）这么多的字节，（*p）++移动了sizeof（int）这么多的字节
       printf("%u, %u, %u, p = %u, *p = %u\n", buf, buf[1], &buf[1][0], p, *p);
       printf("p+1 = %u, *p+1 = %u\n", (p + 1), (*p + 1));
       return 0;
    }

![70][]

\*（\*a+3）和\*（\*（a+1）+2）的结果：\*（a+1）用连长的移动方式，再采用排长的移动方式移动两位。

## ![70 1][] ##

## 1.2 指向指针的指针（二级指针） ##

指针就是一个变量，既然是变量，就也存在内存地址，所以可以定义一个指向指针的指针。以此类推，可以定义3级甚至多级指针。C语言允许定义多级指针，但指针级数过多会增加代码复杂性。实际编程时多用一级、二级指针，三级也不常用

int main() //二级指针
    {
        int a = 10;
        int *p = &a;
        int **pp = &p; //定义了一个二级指针，指向了一个一级指针地址
        **pp = 100; //通过二级指针修改内存的值
        *pp = 15; //相当于p指向了编号为10的这块内存，pp还是正常的指针但p被修改成了野指针
        printf("a = %d\n", a);
        printf("*p = %d\n", *p); //不显示
        return 0;
    }

二级指针与一级指针间的关系

![20180608102027980][]

![20180608104509417][]

## 1.3 指向二维数组的指针 ##

***二维数组中行的表示方法：***

int main()
    {
        int array[3][4] = { 0 };
     // int *p1 = array; //int *这种类型的指针适合指向一维数组
        int (*p1)[4] = array;//int (*指针名)[x]这种写法用来指向二维数组
     //p1++;//表示整行移动，移动了16个字节 //p1[x]与array[x]含义一样，都表示二维数组中的某一行元素。他们占据的内存大小为x*4bit //p1[x][y];//表示数组中某一位的元素
        return 0;
    }

<table style="width:200px;"> 
 <tbody> 
  <tr> 
   <td>int buf[3][5]</td> 
   <td>二维数组名称，buf代表数组首地址</td> 
  </tr> 
  <tr> 
   <td>int(*a)[5]</td> 
   <td>定义一个指向int[5]类型的指针变量a</td> 
  </tr> 
  <tr> 
   <td>a[0]， * (a + 0), &nbsp;*a</td> 
   <td>0行，0列元素的地址</td> 
  </tr> 
  <tr> 
   <td>a + 1</td> 
   <td>第1行首地址</td> 
  </tr> 
  <tr> 
   <td>a[1]， *(a + 1)</td> 
   <td>第1行，0列元素地址</td> 
  </tr> 
  <tr> 
   <td>a[1] + 2，*(a + 1) + 2， &amp;a[1][2]</td> 
   <td>第1行，2列元素地址</td> 
  </tr> 
  <tr> 
   <td>*（a[1] + 2），*（*(a + 1) + 2）， a[1][2]</td> 
   <td>第1行，2列元素的值</td> 
  </tr> 
 </tbody> 
</table>

具体例子：

int main1() //用指针表示多维数组，求每行矩阵的平均値并显示
    {
        int buf1[3][5] = { {2, 4, 6, 5, 7}, {7, 6, 4, 3, 8}, {0, 3, 5, 8, 4} };
        int (*h)[5];//数组指针
        h = buf1;
        int ave_h = 0;
        int i, j;
        for(i = 0; i< 3; i++)
        {
            for(j = 0; j < 5; j++)
            {
               ave_h += *(*(h + i) + j) ;
    
            }
            ave_h = ave_h / 5;
             printf("ave_h = %d\n", ave_h);
        }
    }

int main() //不允许使用下标，只能通过指向二维数组的指针求出数组中的每行和每列的平均値
    {
            int buf[3][5] = { {2, 4, 6, 5, 7}, {7, 6, 4, 3, 8}, {0, 3, 5, 8, 4} };
            int i,j;
            for(i = 0; i < 3; i++) //每行的平均値
            {
                int sum = 0;
                for(j = 0; j < 5; j++)
                {
                   // sum +=buf[i][j];
                    sum += (*(*(buf + i) + j));
                }
                printf("%d\n", sum / 5);
            }
    
            printf("--------------------------------\n");
    
            for(i = 0; i < 5; i++) //每列的平均値
            {
                int sum = 0;
                for(j = 0; j < 3; j++)
                {
                   // sum +=buf[j][i];
                    sum += (*(*(buf + j) + i));
                }
                printf("%d\n", sum /3);
            }
            return 0;
    }

## 1.4 指针变量作为函数的参数 ##

函数的**参数**可以是**指针类型**，它的作用是将一个变量的地址传送给另一个函数。通过函数的指针参数可以间接的实现形参修改实参的值

![70 2][]

void test(int *n) //通过将函数的参数作为指针，那么就可以间接的修改实参的值
    {
        (*n)++;
    }
    int main() //指针变量作为函数的参数
    {
        //int i = 100;
        int i = 0;
        scanf("%d", &i); //所有需要在函数内部修改实参的值，都需要通过将指针作为函数参数调用实现
        test(&i);
        printf("i = %d\n", i);
        return 0;
    }

void swap(int *a, int *b) //形参要用指针形式
    {
        int tmp = *a;
        *a = *b;
        *b = tmp;
    }
    int main()
    {
        int a = 10;
        int b = 20;
        swap(&a, &b);  //要进行ab互换，则实参处要加地址符
        printf("a = %d, b = %d\n", a, b);
        return 0;
    }

![70 3][]

## 1.5 一维数组名作为函数参数 ##

当数组名作为函数参数时，c语言将数组名解释为指针。

int func（int array\[10\]）; = int func（int \*array）；//都是数组名代表数组的首地址

void set_array(int *buf)  //当数组名作为函数的参数时，数组名其实就是一个指针变量
    {
        printf("buf = %d\n", sizeof(buf));
        buf[0] = 100;
        buf[1] = 200;
    }
    void print_array(int buf[]，int n) //跟*buf一样，用数组名代表数组的首地址。n的主要功能是告诉函数内部，这个数组的维度
    {
        int i;
        for(i = 0; i < n; i++)
        {
            printf("buf[%d] = %d\n", i, buf[i]);
        }
    }
    int main()
    {
        int buf[ ] = {4, 5, 2, 6, 1, 3, 8, 9, 7, 10};
        set_array(buf); //放的是数组首地址
        print_array(buf，sizeof（buf）/sizeof（int）); //int buf【】中括号处没数值时，用sizeof（buf）/sizeof（int）来代替数组位数
        return 0;
    }

![70 4][]

## 1.6 二维数组名作为函数参数 ##

二维数组做函数参数时可以不指定第一个下标

eg：int func（int array\[\]\[10\]）;

将二维数组作为函数的参数用例不常见。

void print_buf1(int (*p)[3]) //=void print_buf1(int [][3]) 注：输出时这里的下标不能用sizeof(buf1) / sizeof(buf1[0])代替。 //将二维数组作为函数参数传递的时候，定义为指针类型。
    {
        int i, j;
        for(i = 0; i< 3; i++)
        {
            for(j = 0; j < 5; j++)
            {
               printf("p[%d][%d] = %d\n", i, j, p[i][j]);
            }
        }
    }
    int main()
    {
        int buf1[3][5] = { {2, 4, 6, 5, 7}, {7, 6, 4, 3, 8}, {0, 3, 5, 8, 4} };
        print_buf1(buf);
        return 0;
    }

void print_buf2(int (*p)[3], int a, int b) //将二维数组作为函数参数传递的时候，定义为指针类型
    {
        int i, j;
        for(i = 0; i< a; i++)
        {
            for(j = 0; j < b; j++)
            {
               printf("p[%d][%d] = %d\n", i, j, p[i][j]);
            }
        }
    }
    int main() //用指针形式显示二维数组的每个值
    {
        int buf1[3][5] = { {2, 4, 6, 5, 7}, {7, 6, 4, 3, 8}, {0, 3, 5, 8, 4} };
        print_buf2(buf1, sizeof(buf1) / sizeof(buf1[0]), sizeof(buf1[0]) / sizeof(int));
        return 0;
    }

## 1.7 const关键字保护数组内容 ##

如果一个数组作为函数的形参传递，那数组内容可以被调用函数内部修改，有时候不希望发生这样的事，所以要对形参采用const参数。

func （const int array）

void mystrcat(char *s1, const char *s2)
    //增加了const关键字后，保护相应的参数值不变
    {
        int len = 0;
        while(s2[len])
        {
            len++; //get the length of s2
        }
        printf("%d\n", len);
        while(*s1)
        {
            s1++;
        }
        int i;
        for(i = 0; i < len; i++)
        {
            *s1 = *s2;
            s1++;
            s2++;
        }
    }
    int main() //将两个字符串合到一块
    {
        char s1[10] = "abc";
        char s2[10] = "bcd";
        mystrcat(s1, s2);
        printf("s1 = %s\n", s1);
        return 0;
    }

## 1.8 指针做函数的返回值 ##

char *mystrchar(char *s, char c)
    {
        while(*s)
        {
            if(*s == c)
                return s;
            s++;
        }
        return NULL;
    }
    int main()//指针做函数的返回值
    {
        char str[20] = "hello world";
        char *p = mystrchar(str, 'e');
        printf("%s\n", p);
        return 0;
    }

![70 5][]

![70 6][]

## 1.9 不允许使用下标，只能通过指向二维数组的指针求出数组中的每行和每列的平均値 ##

int main7() //不允许使用下标，只能通过指向二维数组的指针求出数组中的每行和每列的平均値
    {
            int buf[3][5] = { {2, 4, 6, 5, 7}, {7, 6, 4, 3, 8}, {0, 3, 5, 8, 4} };
            int i,j;
            for(i = 0; i < 3; i++) //每行的平均値
            {
                int sum = 0;
                for(j = 0; j < 5; j++)
                {
                   // sum +=buf[i][j];
                    sum += (*(*(buf + i) + j));
                }
                printf("%d\n", sum / 5);
            }
    
            printf("--------------------------------\n");
    
            for(i = 0; i < 5; i++) //每列的平均値
            {
                int sum = 0;
                for(j = 0; j < 3; j++)
                {
                   // sum +=buf[j][i];
                    sum += (*(*(buf + j) + i));
                }
                printf("%d\n", sum /3);
            }
            return 0;
    }

## 1.10 指向函数的指针 ##

**指针可以指向变量、数组、也可以指向一个函数。**

**    一个函数在编译的时候会分配一个入口地址，这个入口地址就是函数的指针，函数名称就代表函数的入口地址。**

函数指针的定义方式：int（\*p）(int);// 定义了一个指向int func（int n）类型函数地址的指针

1、定义函数指针变量的形式为：函数返回类型（\*指针变量名称）（参数列表）；

2、函数可以通过函数指针调用；

3、int（\*p）（）代表指向一个函数，但不是固定哪一个函数。

int main() //函数指针
    {
        void *p(int, char*); //声明了一个函数，函数是名字叫p，函数的返回值是void*，函数的参数是int和char*
        void (*p) (int, char*);//定义了一个函数，函数是名字叫*p，函数的返回值是void，函数的参数是int和char*
        int *(*p)(int*); //定义了一个参数为int*，返回值为int*的指向函数的指针。(*p)表示指向函数的指针
        int *p(int*); //声明了一个函数，返回值是int*，参数是int*
        int (*p)(int, int);//定义了一个指向函数的指针，可以指向两个参数，都是int，返回值也是int这种类型
    }

## 1.11 回调函数（C语言中最高级的用法） ##

将函数指针作为另一个函数的参数称为回调函数

int add(int a, int b)
    {
        int sum = a + b;
        return sum;
    }
    int fun(int(*p1)(int, int), int a, int b) //第一个参数是指向函数的指针
    {
        return p1(a, b); //通过指向函数的指针调用一个函数
    }
    int main()//回调函数
    {
        int i = fun(add, 6, 9); //add函数在这里就叫回调函数。
        printf("i = %d\n", i);
        return 0;
    }

![70 7][]

## 1.12 memset，memcpy，memmove函数 ##

这三个函数分别实现内存设置，内存拷贝和内存移动。使用memcy时，一定要确保内存**没有重叠区域**。

memset函数可以对内容比较多的数组进行初始化或赋一定的值。使用memset函数时，首先要包含\#include <string.h>头文件

int main()
    {
        int buf[10] = { 0 };
        buf[1] = 2;
        buf[4] = 5;
        int i;
        memset(buf, 1, sizeof(buf));//第一个参数表示要设置的内存地址，第二个参数是要设置的值，第三个参数是内存的大小，单位：字节
        //C语言中将一块内存初始化为0最常见的办法
    for(i = 0; i < 10; i++)
        {
            printf("buf[%d] = %d\n", i ,buf[i]);
        }
        return 0;
    }

## ![70 8][]    ![70 9][] ##

使用memcy时，一定要确保内存**没有重叠区域**

**![70 10][]**

## ![70 11][] ##

## memcpy ##

memcpy（str2, str1, sizeof(str1）;//将str1的内容复制到str2上，大小为sizeof

[70]: /images/20220523/bdbfdfb627e045f68e38275af2b6516f.png
[70 1]: /images/20220523/ea0a052e8c204888a1e5c7a9fbe84705.png
[20180608102027980]: /images/20220523/18bbdef857504ecb9e1ebc8d0b2618eb.png
[20180608104509417]: /images/20220523/c2d552f94b96411e94339523f9a54fdb.png
[70 2]: /images/20220523/cfec25d2f37c464f825eec63be0f2427.png
[70 3]: /images/20220523/a205a91778a6471fb5e14ee0e9a8bcaf.png
[70 4]: /images/20220523/a89858c4131c42beb8693fab091642c0.png
[70 5]: /images/20220523/ae93b49f3ba04c81a3f317cd1b6fe20d.png
[70 6]: /images/20220523/d274b2f04c184f7782e781f905446320.png
[70 7]: /images/20220523/180f96eb41a04b28844b84467e173b41.png
[70 8]: https://img-blog.csdn.net/20180611090102728?watermark/2/text/aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3NzY0MTI5/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70
[70 9]: /images/20220523/17037ee9cbbd4554ad2fc3082c64c7bb.png
[70 10]: /images/20220523/4b155ef07f0844ffb84881bd78adcc91.png
[70 11]: /images/20220523/fecbcf907cd14c2c9dcbe76b6c9fe89c.png