赞
踩
针对指针,之前的文章中也就简单介绍过了,本章是针对已经简单了解了解指针,进行的一系列扩展与探究,所以如果读者还未简单了解指针,请先去看一下我之前对于指针的文章,再回来阅读。
指针变量的大小和类型无关,只要是指针变量,就是为了储存地址的,而地址大小与地址总线有关,所以在同一个平台下,指针变量大小都是一样的,那为什么还要有各种各样的指针类型呢?
这里有两段代码就可以说明这个问题:
- //代码1
- int main()
- {
- int n = 0x11223344;
- int* pi = &n;
- *pi = 0;
- printf("%x", n);
- return 0;
- }
- //代码2
- int main()
- {
- int n = 0x11223344;
- char* pi = &n;
- *pi = 0;
- printf("%x", n);
- return 0;
- }
调试运行之后,我们可以发现,代码1会将n的4个字节全部改为0,而代码2却只是将n的第一个字节改成0,结果是11223300,但为什么n的第一个字节是44,这个我们之后再做解释。
结论: 指针的类型决定了,对指针解引用的时候有多大的权限(一次能操作几个字节)。
比如: char* 的指针解引用就只能访问一个字节,而int* 的指针解引用就能访问四个字节。
首先先看一段代码
- #include <stdio.h>
- int main()
- {
- int n = 10;
- char* pc = (char*)&n;
- int* pi = &n;
- printf("&n = %p\n", &n);
- printf("pc = %p\n", pc);
- printf("pc+1 = %p\n", pc+1);
- printf("pi = %p\n", pi);
- printf("pi+1 = %p\n", pi+1);
- }
运行结果如下:
这是在32位环境下运行出来的结果,我们可以看出,char* 类型的指针变量+1跳过了1个字节,int* 类型的指针变量+1 跳过了4个字节,这就是指针变量的类型差异所带来的变化。
结论:指针的类型决定了指针向前或者向后一步有多大(距离)。
在指针类型中有一种特别的类型是void* 类型的,可以理解为无具体类型的指针(或者叫泛型指针),这种类型的指针可以用来接受任意类型地址。但是也有局限性,void* 类型的指针不能直接进行指针的+- 整数呵解引用的运算。
例如:
- int main()
- {
- int a = 10;
- int* pa = &a;
- char* pc = &a;
- return 0;
- }
在上面的代码中,将一个int类型的变量的地址赋值给一个char* 类型的指针变量。编译器给出了一个警告(如下图),是因为类型不兼容。而使用void* 类型就不会有这样的问题。
使用void* 类型的指针接收地址:
- int main()
- {
- int a = 10;
- void* pa = &a;
- void * pc = &a;
- *pa = 0;
- *pc = 0;
- return 0;
- }
运行结果:
这里我们可以看到,void*类型的指针可以接收不同类型的地址,但是无法直接进行指针运算。
那么void*类型的指针到底有什么用呢?
因为它的泛型特性,即可以接收不同类型的地址,一般void* 类型的指针是使用在函数参数的部分,这样的设计可以实现泛型编程的效果。是一个函数可以用来处理多种类型的数据。
变量是可以修改的,如果把变量的地址交给一个指针变量,通过指针变量的解引用也可以修改这个变量。但是如果我们不希望变量可以通过解引用的方式来进行修改呢? 我们应该怎么操作?
这就是const 的作用。
‘ 在前面的学习中,我们知道了const 的作用是可以将所修饰的变量转化为常变量,使其无法被直接赋值修改,但是却可以通过地址解引用修改,那么,const 能否修饰指针,来达到 通过地址也无法修改呢?
下面我们看代码,来分析
- 代码1
- 测试无const修饰的情况
- int main()
- {
- int n = 10;
- int m = 20;
- int* p = &n;
- *p = 20;
- p = &m;
- return 0;
- }
运行结果: 可以正常运行。
- 代码2
- 测试const 放在*的左边情况
- int main()
- {
- int n = 10;
- int m = 20;
- const int* p = &n;
- *p = 20;
- p = &m;
- printf("%d %d", n, m);
- return 0;
- }
运行结果:*p出错,无法解引用,但是指针p还是可以赋值。
- 代码3
- 测试const 放在*的右边情况
- int main()
- {
- int n = 10;
- int m = 20;
- int* const p = &n;
- *p = 20;
- p = &m;
- printf("%d %d", n, m);
- return 0;
- }
运行结果: p出错,无法给指针p赋值,但是可以进行解引用赋值操作。
- 代码4
- 测试*的左右两边都有const
- int main()
- {
- int n = 10;
- int m = 20;
- cosnt int * const p = &n;
- *p = 20;
- p = &m;
- printf("%d %d", n, m);
- return 0;
- }
运行结果: p,*p出错,无法给指针p赋值,同时无法进行解引用赋值操作。
结论: const修饰指针变量的时候
指针的基本运算又三种,分别是:
因为数组在内存中是连续存放的(地址由低到高),只要知道第一个元素的地址,就能顺藤摸瓜找到后面的所有元素。
- int main()
- {
- int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
- int* p = &arr[0];
- int i = 0;
- int sz = sizeof(arr) / sizeof(arr[0]);
- for (int i = 0; i < sz; i++)
- {
- printf("%d ", *(p + i)); // p+i 这里就是指针 + 整数
- // 这里p的增值是看p的类型的 如 p是int 那么 p+1 则为p向后4个字节,指向下一个整数变量
- // 指针变量移动大小看 具体是什么类型的指针变量 如 char* a a+1 就是a指针向后移动一个字节
- // int* a a+1 则是移动4个字节
- }
- return 0;
- }
注:指针-指针的运算前提是 两个指针指向的是同一块内存空间(语法上不出错,但不提倡)
- int my_strlen(char* s)
- {
- char* p = s;
- while (*p != '\0') p++;
- return s-p; //这里指针-指针
- }
- int main()
- {
- printf("%d\n", my_strlen("abc")); // "abc" 这种形式的字符串,本质上就是字符型数组
- // "abc"就是首元素的地址
- return 0;
- }
- int main()
- {
- int arr[10] = { 0 };
- printf("%d\n", &arr[9] - &arr[0]);
- char ch[20] = { 0 };
- printf("%d\n", &arr[0] - &ch[0]);
- //这种的语法上不出错,但是得到的值没有意义
-
- return 0;
- }
- int main()
- {
- int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
- int* p = &arr[0];
- int i = 0;
- int sz = sizeof(arr) / sizeof(arr[0]);
- while (p < arr + sz) //指针的大小比较,其实就是地址之间的比较
- {
- printf("%d ", *p);
- p++;
- }
- return 0;
- }
概念: 野指针就是指针指向的位置是不可知的(随机的、不正确的、没有明确限制的)
局部变量如果没有初始化的话,由于它是存储在内存的栈区,所以它的值将会是随机值(0xcccccccc)这也就诞生了野指针,但如果是全局变量,或静态变量,由于他们是存储在静态区,所以他们的值为0。
- int main()
- {
- int* p; //局部变量指针未初始化,默认为随机值
- *p = 20;
- return 0;
- }
- int main()
- {
- int arr[10] = { 0 };
- int* p = &arr[0];
- int i = 0;
- for (int i = 0; i <= 11; i++)
- {
- //当指针指向的范围超出数组arr的范围时,p指针就是野指针
- *(p++) = i;
- }
- return 0;
- }
- int* test()
- {
- int n = 100;
- return &n;
- }
-
- int main()
- {
- int* p = test();
- //函数中n是局部变量,函数结束后就会自动销毁
- //所以所返回的指针就为野指针
- printf("%d\n", *p);
-
- return 0;
- }
根据我们所学的函数栈帧知识,思考为什么将代码改为下面这样它的p值就改变了?
- int* test()
- {
- int n = 100;
- return &n;
- }
-
- int main()
- {
- int* p = test();
-
- printf("haha\n");
-
- printf("%d\n", *p);
-
- return 0;
- }
如果明确知道指针指向哪里就直接赋值地址,如果不知道指针应该指向哪里,可以给指针赋值NULL。
NULL 是C语言中定义的一个标识符常量,值为0,0也是地址,但是这个地址是无法使用的,读写该地址会报错。
- #ifdef __cplusplus
- #define NULL 0
- #else
- #define NULL ((void *)0)
- #endif
初始化如下:
- int main()
- {
- int num = 10;
- int* p1 = #
- int* p2 = NULL;
-
- return 0;
- }
一个程序向内存申请了那些空间,通过指针也就只能访问哪些空间,不能超出范围访问,超出了就是越界访问,所得到的值也是不可预料的。
4.2.3 指针变量不再使用时,即使置为NULL,指针使用之前检查有效性
当指针变量指向一块区域的时候,我们可以通过指针访问该区域,后期不再使用这个指针访问空间的时候,我们可以把该指针置为NULL。因为约定俗成的一个规则就是:只要时NULL指针就不去访问,同时使用指针之前可以判断指针是否为NULL。
- int main()
- {
- int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
- int* p = &arr[0];
- for (int i = 0; i < 10; i++)
- {
- *(p++) = i;
- }
- //出来后p已经越界了,可以把p置为NULL
- p = NULL;
- //下次使用的时候,判断p不为NULL的时候再使用
- //...
- //...
- if (p != NULL)
- {
- //...
- }
- return 0;
- }
如造成野指针的第3个例子,不要返回局部变量的地址
assert.h 头文件定义了 宏assert(), 用于在运行时确保程序符合指定条件,如果不符合,就报错终止运行。这个宏常常被称为“断言”。
assert(p != NULL);
上面代码在程序运行到这一行语句时,会验证变量p 是否等于NULL。如果确实不等于NULL,程序会继续运行,反之则会终止运行,并且给出报错信息提示/
assert() 宏接受一个表达式作为参数。如果该表达式为真(返回值非零), assert()不会产生任何作用,程序继续运行。如果该表达式为假(返回值为零), assert()就会报错,在标准错误流stderr中写入一条错误信息,显示没有通过的表达式,以及包含着表达式的文件名呵行号。
assert()的使用对程序员是非常友好的,使用assert()有几个好处:它不仅能自动标识文件和出问题的行号,还有一种无需更改代码就能开启或关闭assert()的机制。如果已经确定程序没有问题,不需要再做断言,就在#include < assert.h> 语句的前面,定义一个宏 NDEBUG。
- #define NDEBUG
- #include <assert.h>
然后,重新编译程序,编译器就会禁用文件中所有assert()语句。如果程序又出现问题,可以移除这条 #define NDEBUG 指令(或者把它注释掉), 再次编译,这样就重新启用了 assert()语句。
assert()的缺点是,因为引入了额外的检查,增加了程序的运行时间。
一般我们可以在Debug中使用,在Release 版本中选择禁用 assert 就行,在VS这样的集成开发环境中,在Release版本中,直接就是优化掉了。这样在debug版本写有利于程序员排查问题,在Release版本不影响用户使用时程序的效率。
Copyright © 2003-2013 www.wpsshop.cn 版权所有,并保留所有权利。