C语言学习第四阶段-指针

最新推荐文章于 2023-12-22 11:44:15 发布

永不秃头的程序员

最新推荐文章于 2023-12-22 11:44:15 发布

阅读量138

点赞数

分类专栏： C语言学习

本文链接：https://blog.csdn.net/weixin_51178981/article/details/113873845

版权

C语言学习专栏收录该内容

26 篇文章 12 订阅

订阅专栏

记住一句话指针就是地址

一、指针的基本类型

int p; // 这 是 一 个 普 通 的 整 型 。

int *p; /*首 先从 P 处 开 始, , 先 与* * 结 合,  所 以 说明 P 是 一
 个 指 针,然 后 再 与 int 结 合,  说 明 指 针 所 指 向 的 内 容 的 类 型 为 int  型 所以 以 P  是 一 个 返 回 整 型 数 据 的 指针。*/

int p[3]; /* 首 先从 P 处 开 始, , 先 与 [] 结 合,  说明 P 是 一 个 数 组, 然 后与int  结 合,说 明 数 组 里 的 元 素 是 整 型 的, 所 P 是 一 个 由 整 型 数 据 组 成 的 数*/

int *p[3]; // 首 先从P处 开 始,先 与 [] 结 合, , 因 为 其 优 先 级比* 高, , 所 以 P  是 一 个 数 组,  然 后 再 与* 结 合,  说 明 数 组 里 的 元 素 是 指 针 类 型, 然 后 再 int  结 合, 说 明 指 针 所 指 向 的 内 容 的 类 型 是 整 型 的, 所 以P 是 一 个 由 返 回 整 型 数 据 的 指 针 所 组 成 的 数*/

int (*p)[3]; /* 首 先 从 P 处 开 始, 先 与* 结 合, 说 明 P  是 一 个 指 针 然 后 再与 [] 结 合( ( 与 "()" 这 步 可 以 忽 略, 只 是 为 了 改 变 优 先 级 ), 说 明 指 针 所 指 向 的 内 容 是 一 个 数 组, , 然 后 再与 与 t int  结 合, , 说 明 数 组 里 的 元 素 是 整 型 的. 所以 P  是 一 个 指 向 由 整 型 数 据 组 成 的 数 组 的 指 针*/

int **p; /*首 先 从 P  开 始, , 先 与* * 结 合 , 说 是 P  是 一 个 指 针, 后 再 与* * 结 合, 说 明 指 针 所 指 向 的 元 素 是 指 针,  然 后 再 与  int  结 合,  说 明 该 指 针 所 指 向 的 元 素 是 整 型 数 据.  由 于 二 级 指 针 以 及 更 高 级 的 指 针 极 少 用 在 复 杂 的 类 型 中, , 所 以 后 面 更 复 杂 的 类 型 我 们 就 不 考 虑 多 级 指 针 了, 最 多 只 考 虑 一 级 指 针. */

int p(int);  /*从 P 处 起, , 先 与 () 结 合,  说 明 P  是 一 个 函 数, , 然 后 进 入 () 里 分 析, 说 明 该 函 数 有 一 个 整 型 变 量 的 参 数 然 后 再 与 外 面 的 t int  结 合, 说 明 函 数 的 返 回 值 是 一 个 整 型 数。*/

 int (*p)(int);  /*从 P 处 开 始, 先 与 指 针 结 合, 说 明 P  是 一 个 指 针, , 然 后 与() 结 合, , 说 明 指 针 指 向 的 是 一 个 函 数,  然 后 再 与 () 里 的 int  结 合,  说 明 函 数 有 一个 int  型 的 参 数, 再 与 最 外 层 的 int  结 合, 说 明 函 数 的 返 回 类 型 是 整 型, 所 以 P  是 一 个 指向 有 一 个 整 型 参 数 且 返 回 类 型 为 整 型 的 函 数 的 指 针*/

二、指针的类型

从语法的角度看，你只要把指针声明语句里的指针名字去掉，剩下的部分就是这个指针的类型。这是指针本身所具有的类型。让我们看看例一中各个指针的类型：

(1)int*ptr;// 指 针 的 类 型是 是  int*
(2)char*ptr;// 指 针 的 类 型是 是  char*
(3)int**ptr;// 指 针 的 类 型是 是  int**
(4)int(*ptr)[3];// 指 针 的 类 型是 是 int(*)[3]
(5)int*(*ptr)[4];// 指 针 的 类 型是 是  int*(*)[4]

三、指针所指向的类型

从语法上看，你只须把指针声明语句中的指针名字和名字左边的指针声
明符* * 去掉，剩下的就是指针所指向的类型。例如：

(1)int*ptr; // 指 针 所 指 向 的 类 型 是  int
(2)char*ptr; // 指 针 所 指 向 的 的 类 型 是  char
(3)int**ptr; // 指 针 所 指 向 的 的 类 型 是  int*
; (4)int(*ptr)[3];  // 指 针 所 指 向 的 的 类 型 是  int()[3]
(5)int*(*ptr)[4]; // 指 针 所 指 向 的 的 类 型 是 int*()[4]

四、指针的值 ---- 或者叫指针所指向的内存区或地址

指针的值是指针本身存储的数值，这个值将被编译器当作一个地址，而不是一个一般的数值。在 32 位程序里，所有类型的指针的值都是一个 32 位整数，因为 32 位程序里内存地址全都是 32 位长。
指针所指向的内存区就是从指针的值所代表的那个内存地址开始，长度为 sizeof( 指针所指向的类型) ) 的一片内存区。
我们说一个指针指向了某块内存区域，就相当于说该指针的值是这块内存区域的首地址。
指针所指向的内存区和指针所指向的类型是两个完全不同的概念。指针所指向的类型已经有了，但由于指针还未初始化，所以它所指向的内存区是不存在的，或者说是无意义的，所以就叫野指针。

五、指针本身所占据的内存

其实，这个问题很简单，稍微上网一搜，你就知道：
一个指针在32位的计算机上，占4个字节；
一个指针在64位的计算机上，占8个字节。
首先，我们要明白，指针就是地址，地址就是指针。而地址是内存单元的编号。所以，一个指针占几个字节，等于是一个地址的内存单元编号有多长。

#include <stdio.h>
int main()
{
        char ch = 'A';
        int i = 99;
        double x = 66.6;

        char *p = &ch;
        int *q = &i;
        double *r = &x;

        printf("%ld  %ld  %ld\n", sizeof(p), sizeof(q), sizeof(r));
        return 0;
}
~

在这里插入图片描述我自己用的64位的操作系统，所以显示的是8，但是可以看出，无论的字符型，还是整形，还是双精度型指针买他们本身占用的内存是一定的。

6、数组和指针的关系

1、数组名就是数组中第一个元素的地址：

#include <stdio.h>
int main()
{
	char array[128] = {0};
	printf("请输入你的名字：\n");\
	scanf("%s",array);//字符串读取不需要加取地址符号
	printf("你的名字的地址是：%p\n",array);
	printf("你的名字的第一个元素的地址是：%p\n",&array[0]);
	return 0;
}

我们在liunx下运行看结果
在这里插入图片描述事实证明是这样的。

2、通过指针（就是地址）来对数组进行访问

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

在这里插入图片描述
我们通过指针的方式来访问数组，同样也可以达到目的，这里的加一是地址往后移动一个整形数组的长度，而不是简单的数组中的值加一。

3、通过数组的下标法来访问指针

#include <stdio.h>
#include <string.h>
int main()
{
		char *array = {"xiaoheihei"}; //定义一个字符串指针
        int a,b;
        b = strlen(array);//b就是这串字符串的长度
        for(a = 0;a<b;a++)
        {
                printf("%c",array[a]);//通过数组的下标法来访问定义的指针
        }
        printf("\n");
	return 0;
}

在这里插入图片描述同样的，数组通过依次读取打印指针的字符，同样可以输出。

4、取地址符的差距

#include <stdio.h>
int main()
{
        int a;
        int *p = &a;
        printf("请输入一个整数:\n");
        scanf("%d",&a);//a是一个整形变量，scanf是用来保存输入变量的地址，所以需>要取地址符
        printf("a = %d\n",a);
        printf("请再输入一个整数：\n");
        scanf("%d",p);//p是一个指针，存放的就是地址，所以p不用取地址符
        printf("a = %d",a);
        return 0;
}
~

在这里插入图片描述要明白指针的取地址符和（&）和取值运算符的差距（*）。

七、避免产生野指针

NULL 指向一个不被使用的地址，而这个地址一’\0’结束，表示字符串的结尾。
产生野指针的危害：

#include <stdio.h>
int main()
{
        int *p1;
        int *p2 = NULL;

        printf("p1 address is %d\n",*p1);
        printf("p2 address is %d\n",*p2);

        return 0;
}

这段代码是在哔哩哔哩“小甲鱼学C”上看到的，但是我的linux不能编译提示段错误，他的编译及结果是

p1 address is 32655995； //随机指向内存中的一个地址
p2 address is Unusable address;//会提示你这是一个不能使用的地址。

为什么不能使用p1这种方式的原因是，这个地址是随机的，可以运行的，如果你的程序没有报错，但是执行的结果是错误的，在代码很长的时候，你没办法去找，所以为了避免这个错误。所以不能使用这种野指针。

永不秃头的程序员

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
C语言学习第四阶段-指针

一、
复制链接

扫一扫

专栏目录

C语言学习第四阶段-指针

一、指针的基本类型

二、 指 针 的 类 型

三、指 针 所 指 向 的 类 型

四、指 针 的 值 ---- 或 者 叫 指 针 所 指 向 的 内 存 区 或 地 址

五、 指 针 本 身 所 占 据 的 内 存