C语言进阶之指针（1）

                                                   

               ✨ 猪巴戒：个人主页✨

               所属专栏：《C语言进阶》

        🎈跟着猪巴戒，一起学习C语言🎈

 

目录

 

前情回顾：

1.字符指针

 题目

2.指针数组

指针数组的使用

3.数组指针

3.1数组指针的定义

3.2&数组名VS数组名

3.3 数组指针的常见用法

4.类型决定跳过的步长

---

 

前情回顾：

1. 指针就是个变量，用来存放地址，地址唯一标识的一块内存空间。
2. 指针的大小是固定的4/8个字节（32位平台/64位平台）
3. 指针是有类型、指针的类型决定了指针的+-整数的步长，指针解引用操作的时候的权限。
4. 指针的运算

---

1.字符指针

char*

 

char ch = 'w';
char* pc = &ch;

 pc就是指向ch地址的指针变量，就是我们的字符指针。

pc前面的char*，为表示pc是一个字符指针。

 

*pc = 'b';

printf("%c\n",ch);

通过*pc，可以间接改变变量ch的值

char* p = "abcdef";
printf("%s\n",p);

char*类型存放的是地址，只有4个字节（在x86的环境下，那么它是怎样打印字符串的呢？）

这里"abcdef"并不是直接赋给 p,而是将首元素的地址，a的地址传给了p。

字符串的默认以\0结尾，当printf函数会打印直到遇到\0，停止打印

 

 

const char* p = "abcdef";
*p = 'w';

一般来说，char* p = 的右边是变量，可以通过 *p来修改右边变量的值

当右边为常量字符串"abcdef" 时，我们使用*p进行修改的时候，系统就会报错。

函数const修饰的char* p所指向的对象不可被修改，通过const避免系统报错。

 

---

 题目

下面代码打印的结果是什么？

#include <stdio.h>
int main()
{
    const char* p1 = "abcdef";
    const char* p2 = "abcdef";
    
    char arr1[]="abcdef";
    char arr1[]="abcdef";

    if(p1 == p2)
        printf("p1 == p2\n);
    else
        printf("p1 ! = p2\n");

    if(arr1 == arr2)
        printf("arr1 == arr2\n");
    else
        printf("arr1 ! = arr2\n");

    return 0;

}

 p1和p2指的是常量字符串"abcdef"放在内存的只读数据区，这个空间只能读不能改，它们指向的是常量字符串"abcdef"，所以它们的地址也是相等的。

arr1 == arr2 比较的是地址。

建立函数，会在内存中栈区给arr1和arr2数组独立开辟空间进行存放元素 ，

#数组名表示首元素的地址，都是a的地址，但是地址不一样。

---

2.指针数组

指针数组是一个存放指针的数组。

1|int* arr1[10];//整形指针的数组
2|char* arr2[4];//一级字符指针的地址
3|char** arr3[5]; //二级指字符针的地址

 1|数组中有10个元素，每个元素的类型为 int* ,即整形指针

 1|数组中有4个元素，每个元素的类型为 char* ,即字符指针

 1|数组中有5个元素，每个元素的类型为 char** ,即字符二级指针

---

指针数组的使用

 

int main()
{
    int arr1[] = { 1,2,3,4,5 };
    int arr2[] = { 2,3,4,5,6 };
    int arr3[] = { 3,4,5,6,7 };

    int* parr[3] = { arr1,arr2,arr3 };

    int i = 0;
    for(i=0;i<3;i++)
    {
        int j = 0;
        for(j=0;j<5;j++)
        {

            printf("%d ",*(parr[i]+j)); 
            
            //*(p+1)-->p[i]
            //printf("%d ",parr[i][j]);也可以写成这种形式
        }
        printf("\n");
    }
    return 0; 
}

数组 parr 有3个元素，每个元素都是 int* 类型，arr1,arr2,arr3都表示的是数组首元素的地址，指向的分别是数组首元素1，2，3

通过数组parr，我们就可以打印数组arr1，arr2, arr3

*（p+1）等同于p[ i ],我们就可以把 *(parr[i]+j) 写成 parr[i][j].

 

 

3.数组指针

3.1数组指针的定义

数组指针是数组还是指针？

答案：指针。

int* p1[10];
int (*p2)[10];
//p1,p2分别是什么？

 p1是指针数组，p2是数组指针。

p1没有和没有（）与[10]结合，代表有10个元素的数组，每个数组的类型是int*

p2有（）与 * 结合，代表p2是一个指针，指向的是[10]，10个整形元素的数组。

3.2&数组名VS数组名

数组名通常表示的是数组首元素的地址

但是有2个例外：

1.sizeof(数组名)，这里的数组名表示整个数组，计算的是整个数组的大小

2.&数组名 ，这里的数组名表示的依然是整个数组，使用&数组名取出的是整个数组的地址。

int main()
{
    int arr[10] = {0};
    printf("%p\n",&arr);    
    printf("%p\n",arr);
    printf("%p\n",&arr[0]);

    int sz = sizeof(arr);//这里的arr表示的是整个数组，计算的是整个数组的大小。
    printf("%d\n",sz);

    return 0;
}

数组的地址和数组首元素的地址的表现形式是一样的，但是它们之间有所不同。 

printf("%p\n",arr);
printf("%p\n",arr+1);

printf("%p\n",&arr[0]);
printf("%p\n",&arr[0]+1);

printf("%p\n",&arr);
printf("%p\n",&arr+1);

一般arr表示的是首元素的地址，一个整形元素就是4个字节，arr+1就是跳过4个字节。

&arr表示的是整个数组，所以当&arr+1，就是跳过一个10个整形元素的数组的地址。就是跳过40个字节.

整形指针是用来存放整形的地址。

字符指针是用来存放字符的地址。

数组指针是用来存放数组的地址。

int arr[10] = {0};
int (*p2)[10] = &arr;

指针(*p2)，指向整形数组的指针int (*p2)[10] ,取地址&arr

int (*)[10]表示的是类型，指向整形数组的指针。

3.3 数组指针的常见用法

void print(int arr[3][5],int r,int c)
{
    int i = 0;
    for(i=0;i<r;i++)
    {
        int j = 0;
        for(j=0;j<c;j++)
        {
            printf("%d ",arr[i][j]);
        }
        printf("\n");
    }

}
int main()
{
    int arr[3][5] = { 1,2,3,4,5,2,3,4,5,6,3,4,5,6,7};
    print(arr,3,5);//传的是首元素的地址

    return 0;
}

print(arr,3,5),arr传的是首元素的地址，

二维数组的首元素地址表示的是第一行的地址，等同于一个5个整形元素的一维数组，所以参数是一个指向5个整形元素的一维数组的指针。int (*p)[5]

 

void print2(int (*p)[5],int r,int c)
{
    int i = 0;
    for(i=0;i<r;i++)
    {
        int j = 0;
        for(j=0;j<c;j++)
        {
            printf("%d ",*(*(p + i)+j));
        }
        printf("\n");
    }
}

 

我们可以将一个二维数组想象成3个一维数组，p指向的就是第一个一维数组，

*p就可以得到arr1，*（p+1）就可以得到 arr2, *(p+2)就可以得到arr3

*p等同于arr1,而数组名arr1表示首元素的地址，即1，想要得到arr1的其他元素，*(*p+j)就可以得到.

printf("%d ",*(*(p + i)+j));

printf("%d ",p[i][j]);//等价

 *(p+i)->p[i],p表示的是首元素的地址，首元素的地址加1，就可以得到第二个元素的地址，

在二维数组中，一维数组arr1( *p )表示的是二维数组arr首元素的地址，所以*p+1表示的就是arr2的地址

*(*p+1)+1)表示的就是arr2中的第二个元素。

4.类型决定跳过的步长

p的类型是：int(*)[5];

p是指向整形数组的，数组5个元素int [5]

p+1->跳过一个5个int元素的数组，就是20个字节

int* p2;

p2+1->跳过一个整形,就是4个字节

int arr[10]={0};

&arr+1-> 跳过40个字节