c语言|pointer（指针）- 重置版 c语言|数据结构

文章目录

指针
指针大小
- 实例
指针类型
- 指针类型的意义1
- - 实例1
  - 实例2
- 指针类型的意义2
- - 实例1
  - 实例 2
- 指针类型的意义3
- - 实例 1
野指针
- 形成野指针的原因
- - 1.指针未初始化
  - 2.指针越界访问
  - 3.当一个指针指向的空间被释放了,或者指针指向的空间被释放了，还有人在使用它。
  - - 栈空间，且使用是先使用高地址，再低地址
  - 避免造成野指针
  - - 实例1
指针运算
- 指针加减整数
- - 例子
  - - 附图
- 指针 -（减）指针
- - 实例1
  - 附图
  - 实例 2
- 指针的关系运算
- - 附图
指针和数组
- 数组
- 指针（一级）
- - 二级指针、
- 指针数组
- 数组指针
- 数组指针与指针数组的区别
本文结束

指针

指针是编程语言中的一个对象，利用地址，它的值直接指向电脑存储器中另一个地方的值，由于通过地址能找到所需变量单元。说明，地址指向该变量单元，因此，将地址形象化的称为“指针” 意思是通过它。能找到以它为地址的内存单元

?
指针大小

指针大小是根据多少位操作系统决定的，32位【4 byte】（因为存放一个32位二进制序列【地址】，需要32bit，也就是4字节）；64位【8 byte】（因为存放一个64位二进制序列【地址】，需要64bit，也就是8字节）

实例

#include int main() {int a = 10; int* pa = &a; printf("%d",sizeof(pa)); // pa是一个指针变量，存储的是整形变量 a 的地址，又因为是32位操作系统，指针大小为 4 byte return 0; }

?
指针类型指针类型的意义1

决定（类型* 指针变量【int* a】）的解引用（*指针变量）操作的操作时，一次可以访问几个字节

实例1

#include int main() {int a = 0x11223344; //一个十六进制数就能换算4个二进制位（4 bit），也就是说2个十六进制就是1字节，8个就是4字节 // 上表达式在内存中的形式为（地址左低右高）44 33 22 11 （2个十六进制就是1字节，8个就是4字节，且存储模式为小端模式【高位字节内容存于高位地址，低位字节内容存于低地址】） int* pa = &a; *pa = 0; // 把 a 内的 4 个字节的内容改成0 printf("%p\n",a); //0000 0000 return 0; }

?
实例2

#include int main() {int a = 0x11223344; //内存形式为 44 33 22 11 char* pa = &a; //char* 字符指针类型，对其指针变量（*pa）解引用可以访问 1字节指针类型决定了指针解引用操作的时候，一次访问几个字节（访问内存的大小）*pa = 0; 内存存储形式为小端： 44 33 22 11 由于指针变量 pa 为字符指针类型，对其解引用访问了 a 在内存中低地址处中第 1 个字节的内容并改成0 即 00 33 22 11（低 ~ 高）printf("%p\n", a); 打印是从高位开始打印 //11 22 33 00 return 0; }

?
指针类型的意义2

指针类型决定了，指针在加减整数的时候，跳过几个字节

实例1

#include int main() {int a = 10; int* pa = &a; char* pb = &a; printf("%p\n", pa); //008FF730 printf("%p\n", pb); //008FF730 printf("%p\n", pa+1); //008FF734int 类型加1，跳过4字节 printf("%p\n", pb+1); //008FF731char 类型加1，跳过1个字节 //减法与之同理 return 0; }

?
实例 2

#include int main() {int arr[10] = { 0 }; // 40 byte int* p = arr; //数组名是首元素地址等价于 &arr[0] 首元素的地址为 int 类型，所以需要一个整形指针变量（int* p）来接收数组首元素的地址 int i = 0; for (i = 0; i < 10; i++) {*(p+i) = 1; 因为对其整形指针变量p 解引用，一次访问四个字节的内容，相当于访问整形数组的一个元素而 i 是一个整形，根据指针类型（指针类型为 int ） + i 等价于跳过 i 个 int 类型的数据那么该语句的作用：是把整数数组的每个元素都初始化为 1printf("%d ",*(p+i)); // 1 1 1 1 11 1 1 1 } return 0; }

?
指针类型的意义3

内存使用更加灵活

实例 1

#include int main() {int arr[10] = { 0 }; // 40 byte char* p = arr; // 注意这里的指针变量 p 为字符指针类型，如果对其解引用一次只能访问一个字节的内容 int i = 0; for (i = 0; i < 40; i++) {*(p + i) = 1; 我们以 16 进制来表示数组在内存中的存储情况 01 00 00 0001 00 00 0001 00 00 0001 00 00 00 。。。。。。因为 *p 一次只能访问一个字节的内容，又因为 i 是一个整形，根据指针类型（指针类型为 char ） + i 等价于跳过 i 个 char 类型的数据通过观察，发现这是一种变相修改数组元素的值 printf("%d ",arr[i]); 01 01 01 0101 01 01 0101 01 01 0101 01 01 0101 01 01 0101 01 01 0101 01 01 0101 01 01 01 1684300916843009168430091684300916843009168430091684300916843009 01 01 01 0101 01 01 01 1684300916843009 } return 0; }

?
野指针

指针指向的位置，是不可预知的（随机的，不正确的，没有明确限制的）

形成野指针的原因 1.指针未初始化

#include int main() {int* p; //没有初始化，不知道里面内容，里面放的是随机值 *p = 20; //通过p里面存的随机值作为地址，找到一块空间，这块空间，不属于当前程序 //造成了非法访问，程序崩溃，那么 p 就是野指针 return 0; }

?
2.指针越界访问

#include int main() {int arr[10] = { 0 }; //10个元素，下标是从0~9 int i = 0; int* p = arr; // arr 这里代表是数组首元素地址，被相对应类型指针变量 p 接收 for (i = 0; i <= 10; i++)//循环11次（i == 0 也是会进入循环体的），，访问第11个元素，而它只有10个元素，越界访问。造成程序崩溃 {*p = i; p++; } return 0; }

?
3.当一个指针指向的空间被释放了,或者指针指向的空间被释放了，还有人在使用它。

#includeint* test() {int a = 10; return &a; 局部变量的生命周期，进入这个范围（a 的范围是 int* test（）这个函数范围）到出这个范围。它的地址用完就要返还电脑（栈空间，而且栈空间的使用是先使用高地址，再使用低地址），此时此地址已不属于我们，但是它把这个地址当做返回值，返回给int* p。 } 注意！虽然这个地址还给电脑，但是里面的内容很可能没改。也就意味着内容可能还在，但不属于不属于我们， //举个例子：宾馆开房，你住的期间，是你的，房屋里面摆放是按照你的要求布置的， //等你退房之后，房间使用权你就没有了，你再使用就是违法的。 //另外等你退房之后，房间并没有改变摆设，等下一个人来住的时候，就按别人的要求摆放，int main() {int* p = test(); // test返回的地址，被 *p记住了（此地址不属于当前程序）printf("hehe\n"); // 打印 hehe 需要向内存申请空间，也就是说 test 函数还给xt的内存，被占用了， // 根据例子 hehe 就是该房间现在的使用者printf("%d\n", *p); //所以这时候 *p 就属于非法访问 //本来上表达式按逻辑来说是随机值，但上表达式a的值还是10； //是因为这个地址还给电脑，但没改。所以内容还在，所以访问还是10，但不属于不属于我们， //如果在输出前面加一个函数或者其他的，向栈里面申请内存，把test还给电脑的内存，给占用了。 //那么*p的输出是无法确定的 return 0; }

?
栈空间，且使用是先使用高地址，再低地址

#include int main() {int a = 10; int b = 20; printf("%p\n",&a); //0113F8 D8 printf("%p\n", &b); //0113F8 CC 在十六进制中 D 比 C要大，也就意味着 a 地址比 b 的地址要大 //由此可见:栈空间，是先使用高地址，再低地址 return 0; }

避免造成野指针

1.指针初始化 2.指针指向空间释放级设置NULL 3.使用地址之前检查有效性 4.避免返回局部变量的地址 5.小心指针越界

?
实例1

#include int main() {int a = 10; //明确地初始化 int* p = &a; //确定指向int* p2 = NULL; //不知道一个指针当前应该指向哪里时，初始化 NULL （空指针； 0的另一种写法） // 初始化 NULL，相当于标记状态，这个指针还没有指向任何对象，要注意了 //如果不初始化，就不知道它指向那块空间。举个例子：指针不初始化相当于街上有一只没有主人的野狗，可能会伤人。指针初始化 NULL，就相当于把它拴在一颗树底下（这棵树，就相当于一个危险标记），防止伤害到人，当然前提是你不去接近，所以我们只需绕着走，就可以避免危险， int* p2 = NULL; 该语句相当于指针初始化 NULL，标记它是野指针，不要去调用它if (p2 != NULL)// 意思就是如果我们没有将 P2 置为空指针，就执行下面的 if 语句 *p2 = 100; 这就相当于你非要去那棵树底下方便，它肯定就会伤害你（这么挑衅的行为，它不咬你才怪）；所以我们去尿尿时，需要提前看一下树底下有没有狗，即该树下没有狗，意味着我们可以去方便（该指针初始化了，且是一个有效地址，我们再去使用它） // p2是一个空指针，空指针是0，0也是地址，0指向的地址是不可使用的 // *p2 = 100; 该表达式是错误的，属于非法操作 return 0; }

指针运算

指针加减整数 /指针 -（减）指针指针的关系运算

?
指针加减整数例子

#include int main() {int arr[10] = { 1,2,3,4,5,6,7,8,9,10}; int i = 0; int sz = sizeof(arr) / sizeof(arr[0]); int* p = arr; for (i = 0; i < sz; i++) {printf("%d ",*(p+i)); // 1 2 3 4 5 6 7 8 9 10 } printf("\n"); for (i = sz-1; i >= 0; i--) {printf("%d ", *(p + i)); //10 9 8 7 6 5 4 3 2 1 } return 0; } 由该程序我们发现，数组名（其实就一个指针【地址】），当我们加上一个整数时，它根据它自身的数据类型来判断就拿上面的程序来说，数组的类型为int 类型，当我们用 arr（首元素地址）+ i（i是一个整数）时，整数 i 会根据数组的类型，来进行判断一次跳过 i 个为 int 类型的数据

附图 【c语言|pointer（指针）- 重置版】

文章图片

?
指针 -（减）指针实例1

#include int main() {char ch[5] = { 0 }; int arr[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }; printf("%d\n",&arr[9] - &arr[0]); //指针 - 指针得到是指针和指针之间（ &arr[0]~&arr[9] //左开右闭区间）的元素的个数 //输出为 9printf("%d\n", &arr[9] - &ch[0]); //这种写法error，因为指针减指针，两者必须是同一块空间里的。 return 0; }

附图

文章图片

?
实例 2

#include int my_strlen(char* arr) {char* start = arr; char* end = arr; while (*end !='\0')//循环结束后 end == '\0' == arr[3] {end++; } return end - start; //arr[3] - arr[0]左开右闭 // 第四个元素减去第一个元素 == 3 }int main() {char arr[] = "bit"; int len = my_strlen(arr); printf("%d\n",len); return 0; }

?
指针的关系运算

#define N_VALLUES 5 // 在程序中遇见N_VALLUES 在预编译期间会被替换成 5 #includeint main() {float values[N_VALLUES]; float *vp; // 1.correct（正确写法）for (vp = &values[ N_VALLUES ]vp > &values[0]/*指针是可以比较大小的*/ ; /*省略了*/ ) // 等价于 for (vp = &values[5]vp > &values[0] ; ) 在 C语言标准中允许指向数组元素的指针与指向数组最后一个元素后面的那个内存位置的指针比较; 而且只是比较地址，并没有对其解引用，所以构不成越界访问有人可能会说 &values[ N_VALLUES ] 不是有 [] 操作符吗？不是应该对其解引用，既然解引用，就会造成越界访问但是其实 & 把 [] 给抵消了。例如： &arr[3] == & *(arr+3) == arr + 3 等价于首元素地址加上 3，还会一个地址 {*--vp = 0; // for 循环条件的省略部分在这里 }// 2. error（错误写法） for (vp = &values[N_VALLUES-1]; vp >= &values[0]; vp--)//C语言的标准，并不保证它能运行 //不允许与指向第一个元素之前的那个内存位置进行比较 C语言标准规定：允许指向数组元素的指针与指向数组最后一个元素后面的那个内存位置的指针比较; 但不允许与指向第一个元素之前的那个内存位置进行比较 {*vp = 0; } return 0; }

附图

文章图片

?
指针和数组数组

#include int main() {int arr[10] = { 0 }; printf("%p\n",arr); //打印首元素地址 printf("%p\n", &arr); //打印数组的起始地址【数组的地址】 printf("%p\n", &arr[0]); //打印首元素地址 //在绝大部分情况，数组名表示是首元素地址 //但有两种情况例外 // &数组名，arr代表的是整个数组的起始地址。 //sizeof(数组名)，arr代表的是整个数组，sizeof计算的是整个数组的大小，单位byteprintf("------------------------\n"); printf("%p\n", &arr[0]); // 00F3F8E8 首地址 printf("%p\n", &arr[0] + 1); //00F3F8EC加了4字节，因为数组元素类型 intprintf("%p\n", &arr); // 00F3F8E8 数组的起始地址【数组的地址】 printf("%p\n", &arr + 1); // 00F3F910 加了40字节（2 * pow（16，1） + 8 * pow（16,0） == 8 + 32 = 40）， //即跳过一个数组你会发现数组的地址和数组首元素地址是一样的，但是意义却不一样，我们通过指针加减整数可以发现两者的不同 return 0; }

?
指针（一级）

#include int main() {int arr[10] = { 0 }; int* p = arr; // 指针变量p 存的是 arr首地址 int i = 0; for (i = 0; i < 10; i++) {printf("%p........%p\n",p+i,&arr[i]); // 两种写法是等价的 p+i 是根据数组首元素地址加减整数 i（其实可以说是下标 i），跳过 i 个 int类型的额元素，来找到我们想要打印的元素地址如果输出是 %d 型，输出元素，需要解引用操作符* //例： *(p+i) 或者 arr[i] } return 0; }

?
二级指针、

#include int main() {int a = 10; //pa 一级指针变量，变量的创建，需要在内存中开辟空间，也就意味着 pa 有着自己的地址 int * pa = &a; //一级指针类型；最右边的*，告诉我们 pa 是一个指针 // 而int，告诉我们 pa 指向的那个对象的类型为 intint* * ppa = &pa; // 二级指针最右边的*，告诉我们 ppa 是一个指针 // 而int*，告诉我们 ppa 指向的那个对象的类型为 int*int** * pppa = &ppa; // 三级指针最右边的*，告诉我们 pppa 是一个指针 // 而int**，告诉我们 pppa 指向的那个对象的类型为 int**// n 级指针，可按照上表达式的规律写出、 //二级指针使用方法 printf("%d\n", **ppa); //*ppa == pa ； *（pa）= a ；**ppa == a // 上下两个表达式是等价的输出为 10 printf("%d\n", a); **ppa = 20; printf("%d\n", **ppa); printf("%d\n", a); //两个表达式输出的结果是 20 return 0; }

?
指针数组

指针数组本质上是一个数组：数组就是主语（subject），指针是个形容词（adjective）指针数组是存放指针的数组举个例子：整形数组 -> 存放整形字符数组 -> 存放字符

#include int main() {int a = 10; int b = 20; int c = 30; // int* a = &a; // int* b = &b; // int* c = &c; int* arr2[3] = { &a,&b,&c }; //它就是一个指针数组 int i = 0; for (i = 0; i < 3; i++) {printf("%p\n", arr2[i]); arr2[i] 就是 a,b,c其中一个元素，而这些元素都是地址所以该表达式打印的是a,b,c 的地址printf("%d\n", *(arr2[i])); 这里就是通过指针数组里存储的 a，b，c的地址，找到 a，b，c，打印其值所以输出的结果为 10 20 30} return 0; }

?
数组指针

数组指针本质上是一个指针：指针是主语（subject），数组是个形容词（adjective）

int* p[5]; // 指针数组是一个大小为5（能存放 5 个元素），且每个元素的元素类型是整形指针类型int(*p)[5]; //数组指针通过括号，让指针变量p 和 * 先结合，使其成为一个指针，该指针指向一个大小为 5（能存放 5 个元素，【且每个元素的元素类型是整形】的数组，所以int(*p)[5]即为一个数组指针

数组指针与指针数组的区别