【C语言】 详谈指针

简介: 【C语言】 详谈指针

一、指针和指针类型

1.1 指针

在初识C语言中,我们就知道:


指针是内存中一个最小单元的编号,也就是地址(编号 == 地址 == 指针)

平时口语中说的指针,通常指的是指针变量,是用来存放内存地址的变量。

在32位的机器上,地址是32个0或者1组成二进制序列,那地址就得用4个字节的空间来存储,所以一个指针变量的大小就应该是4个字节。那如果在64位机器上,如果有64个地址线,那一个指针变量的大小是8个字节,才能存放一个地址。

所以我们有总结:


指针变量是用来存放地址的,地址是唯一标示一个内存单元的。

指针的大小在32位平台是4个字节,在64位平台是8个字节  

int main()
{
  int a = 10;
  //a是整型 占用四个字节的内存空间,每个字节都有对应的地址编号
  int* pa = &a;
  //pa是指针变量
  //&a得到是a的地址(指针),其实得到的是a所占内存中4个字节的起始地址(第一个字节的地址)
  return 0;
}

1.2 指针类型

我们知道变量都有不同的类型,char 、int 、short、float……每个类型对应的大小都不同。而指针变量也有相应的类型。


指针的定义方式是: type + * 。

其实:

char* 类型的指针是为了存放 char 类型变量的地址。

short* 类型的指针是为了存放 short 类型变量的地址。

int* 类型的指针是为了存放 int 类型变量的地址。


我们知道指针变量的大小与数据类型无关,在32位平台上都是4个字节,那么我们只需定义一个指针变量就可以了呀,其实不然,下面就此讨论指针类型的意义。


指针类型的意义:


其一(指针的解引用):

观察以下代码

image.png

我们通过调试—>内存—>&a—>将十六进制的数字“0x11223344”存储到了a当中,a的地址为0x00aff998,我们*pa会发生什么呢?

我们继续按F10调试,a的4个字节的大小都变成了0.

image.png

如果我们强制把a的地址存放到char*的空间里面去(会报警告,显示从int* 到char* 的类型不兼容,这里不影响调试),观察以下代码

image.png

这时,我们发现*pc = 0,调试后,只是将第一个字节的数据改为了0,

总结: 指针类型决定了,在解引用指针的时候有多大权限(能访问几个字节)。

比如:char* 的指针解引用就只能访问一个字节,而 int* 的指针的解引用就能访问四个字节。

其二(指针+-整数):

观察以下代码

image.png

我们分别把a的地址存放到int* 和char* 里面去,分别打印pa 、pa + 1以及pc ,pc + 1的地址,我们不难发现

pa与pc的地址是一样的,因为pa与pc存放的都是a的起始地址。

pa + 1则在pa指针变量的基础上跳过了4个字节的大小,因为pa指针变量指向的是一个int类型,所以 + 1的操作就是跳过一个整型的大小。

pc + 1同理,因为pc指针变量指向的是一个char类型的大小,+ 1就会跳过一个字符类型的大小。

所以,pa+n等于加上了n*sizeof(int),pc+n等于加上了n*sizeof(char)


       总结:指针的类型决定了指针向前或者向后走一步有多大(距离)


1.3指针的类型的应用

#include<stdio.h>
int main()
{
  int arr[10] = { 0 };
  int* p = &arr[0];
  int i = 0;
  for (i = 0; i < 10; i++)
  {
    *p = i + 1;
    p++;
  }
  for (i = 0; i < 10; i++)
  {
    printf("%d ", arr[i]);
  }
  return 0;
}

运行结果:

image.png

二、野指针

概念: 野指针就是指针指向的位置是不可知的(随机的、不正确的、没有明确限制的)

2.1野指针成因

1. 指针未初始化

int main()
{
  int* p; //未初始化,p指向位置的是未知的(随机的),p就是野指针
  *p = 10;
  return 0;
}

2.指针越界访问

#include <stdio.h>
int main()
{
    int arr[10] = {0};
    int *p = arr;
    int i = 0;
    for(i=0; i<=11; i++)
    {
        //当指针指向的范围超出数组arr的范围时,p就是野指针
        *(p++) = i;
    }
    return 0;
}

3.指针指向的空间释放

int* test()
{
  int a = 10;
  return &a;
}
int main()
{
  int* p = test();
  *p = 20;
  return 0;
}

test调用之后返回的是局部变量的地址,但是实际的a变量不存在了,已经出了函数的作用域,已经销毁了,此时的p指针变量就是一个野指针。


2.2 如何规避野指针

 指针初始化

 小心指针越界

 指针指向空间释放,及时置NULL

 避免返回局部变量的地址

 指针使用之前检查有效性

#include <stdio.h>
int main()
{
        int *p = NULL;
        int a = 10;
        p = &a;
        if(p != NULL)
        {
        *p = 20;
        }
    return 0;
}

三、指针运算

3.1指针加减整数

#define N_VALUES 5
int main()
{
  float values[N_VALUES];
  float* vp;
  //指针+-整数;指针的关系运算
  for (vp = &values[0]; vp < &values[N_VALUES];)
  {
    *vp++ = 0;
  }
  return 0;
}

3.2指针减去指针

我们思考以下代码,

#include<stdio.h>
int main()
{
  int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
  int n = &arr[9] - &arr[0];//得到的是之间元素的个数
  printf("%d", n);
  return 0;
}

我们在前面知道,指针加上一个整数等于一个指针,那么在这里我们其实就不难发现,指针减去指针得到的是两个指针之间的元素个数。

image.png

学到这里,我们是不是可以用指针模拟实现一个strlen库函数

代码如下:

#include<stdio.h>
int my_strlen(char* str)
{
  char* begin = str;
  while (*str != '\0')
  {
    str++;
  }
  return str - begin;
}
int main()
{
  char str[] = "abcdef";
  printf("%d", my_strlen(str));
  return 0;
}

3.3指针的关系运算

我们将3.1的代码修改一下,得到以下代码

代码1:

#define N_VALUES 5
int main()
{
  float values[N_VALUES];
  float* vp;
    for(vp = &values[N_VALUES]; vp > &values[0];)
    {
    *--vp = 0;
    }
  return 0;
}

image.png

代码简化,将代码修改一种方式:

代码2:

#define N_VALUES 5
int main()
{
  float values[N_VALUES];
  float* vp;
    for(vp = &values[N_VALUES-1]; vp >= &values[0];vp--)
    {
    *vp = 0;
    }
  return 0;
}

image.png

实际在绝大部分的编译器上是可以顺利完成任务的,然而我们还是应该避免代码2这样写,因为标准并不保证它可行。


标准规定:允许指向数组元素的指针与指向数组最后一个元素后面的那个内存位置的指针比较,但是不允许与指向第一个元素之前的那个内存位置的指针进行比较。


四、指针和数组

指针就是指针,数组就是数组。但指针和数组是有关联的。


数组名是数组首元素的地址。(两种情况除外,前面提到过,可以看看数组章节部分的知识)

#include <stdio.h>
int main()
{
    int arr[10] = {1,2,3,4,5,6,7,8,9,0};
    int* p = arr;//p存放的是数组首元素的地址
    printf("%p\n", arr);
    printf("%p\n", &arr[0]);
    return 0;
}

利用指针访问数组的元素

将int arr[10] = {0} 的元素通过指针初始化为1 2 3 4 … 10.

#include<stdio.h>
int main()
{
  int arr[10] = { 0 };
  int* p = arr;
  int i = 0;  
  for (i = 0; i <  10; i++)
  {
    *p = i + 1;//存放数据
    p++;
  }
  //打印
  p = arr;
  for (i = 0; i < 10; i++)
  {
    printf("%d ",*(p + i));
  }
  return 0;
}

五、二级指针

我们知道,指针变量也是变量,是变量就有地址,那指针变量的地址存放在哪里呢?

这里,我们就要讲到二级指针的概念。

#include<stdio.h>
int main()
{
  int a = 10; //a在内存中申请了4个字节的空间
  //一级指针
  int* pa = &a;//0x0012ff40 pa是指针变量,用来存放地址,也得申请4(8)个字节的空间
  //二级指针
  int** ppa = &pa;//0x0012ff44
    printf("%p",*ppa);//得到的是pa
    printf("%d",**ppa);//得到的是a
  return 0;
}

画图表示:

image.png

解释:int* pa = &a将变量a的地址存放到指针变量pa中去,*表示pa是指针,int说明pa指向的变量是int类型,此时的pa是一个一级指针;int** ppa = &pa,取出指针变量pa的地址,存放到指针变量ppa当中去,*表示ppa是指针,int*则说明ppa指向的pa是int*类型,此时的ppa就是一个二级指针。


*ppa 通过对ppa中的地址进行解引用,这样找到的是 pa , *ppa 其实访问的就是 pa,pa是地址,用%p打印

**ppa 先通过 *ppa 找到 pa ,然后对 pa 再进行解引用操作: *pa ,那么找到的就是a了。

六、指针数组

指针数组是数组还是指针呢?答案是数组,指针数组指的是存放指针的数组,我们观察以下代码具体了解。

#include<stdio.h>
int main()
{
  int a = 10;
  int b = 20;
  int c = 30;
  int* arr[] = { &a,&b,&c };
  int i = 0;
  for (i = 0; i < 3; i++)
  {
    printf("%d ", *(arr[i])); //对数组的元素解引用操作
  }
  return 0;
}

image.png

目录
相关文章
|
5月前
|
C语言
【c语言】指针就该这么学(1)
本文详细介绍了C语言中的指针概念及其基本操作。首先通过生活中的例子解释了指针的概念,即内存地址。接着,文章逐步讲解了指针变量的定义、取地址操作符`&`、解引用操作符`*`、指针变量的大小以及不同类型的指针变量的意义。此外,还介绍了`const`修饰符在指针中的应用,指针的运算(包括指针加减整数、指针相减和指针的大小比较),以及野指针的概念和如何规避野指针。最后,通过具体的代码示例帮助读者更好地理解和掌握指针的使用方法。
103 0
|
11天前
|
存储 人工智能 Java
一文轻松拿捏C语言的指针的基础使用
本文介绍了C语言中的指针概念,包括直接访问和间接访问内存的方式、指针变量的定义与使用、取址运算符`&`和取值运算符`*`的应用,帮助读者深入理解指针这一C语言的核心概念。君志所向,一往无前!
19 0
|
3月前
|
存储 NoSQL 编译器
【C语言】指针的神秘探险:从入门到精通的奇幻之旅 !
指针是一个变量,它存储另一个变量的内存地址。换句话说,指针“指向”存储在内存中的某个数据。
133 3
【C语言】指针的神秘探险:从入门到精通的奇幻之旅 !
|
3月前
|
存储 编译器 C语言
【C语言】指针大小知多少 ?一场探寻C语言深处的冒险 !
在C语言中,指针的大小(即指针变量占用的内存大小)是由计算机的体系结构(例如32位还是64位)和编译器决定的。
294 9
|
3月前
|
安全 程序员 C语言
【C语言】指针的爱恨纠葛:常量指针vs指向常量的指针
在C语言中,“常量指针”和“指向常量的指针”是两个重要的指针概念。它们在控制指针的行为和数据的可修改性方面发挥着关键作用。理解这两个概念有助于编写更安全、有效的代码。本文将深入探讨这两个概念,包括定义、语法、实际应用、复杂示例、最佳实践以及常见问题。
74 7
|
4月前
|
存储 C语言
C语言如何使用结构体和指针来操作动态分配的内存
在C语言中,通过定义结构体并使用指向该结构体的指针,可以对动态分配的内存进行操作。首先利用 `malloc` 或 `calloc` 分配内存,然后通过指针访问和修改结构体成员,最后用 `free` 释放内存,实现资源的有效管理。
334 13
|
4月前
|
存储 C语言 开发者
C 语言指针与内存管理
C语言中的指针与内存管理是编程的核心概念。指针用于存储变量的内存地址,实现数据的间接访问和操作;内存管理涉及动态分配(如malloc、free函数)和释放内存,确保程序高效运行并避免内存泄漏。掌握这两者对于编写高质量的C语言程序至关重要。
109 11
|
4月前
|
存储 程序员 编译器
C 语言数组与指针的深度剖析与应用
在C语言中,数组与指针是核心概念,二者既独立又紧密相连。数组是在连续内存中存储相同类型数据的结构,而指针则存储内存地址,二者结合可在数据处理、函数传参等方面发挥巨大作用。掌握它们的特性和关系,对于优化程序性能、灵活处理数据结构至关重要。
|
4月前
|
算法 C语言
C语言中的文件操作技巧,涵盖文件的打开与关闭、读取与写入、文件指针移动及注意事项
本文深入讲解了C语言中的文件操作技巧,涵盖文件的打开与关闭、读取与写入、文件指针移动及注意事项,通过实例演示了文件操作的基本流程,帮助读者掌握这一重要技能,提升程序开发能力。
266 3
|
4月前
|
存储 算法 程序员
C 语言指针详解 —— 内存操控的魔法棒
《C 语言指针详解》深入浅出地讲解了指针的概念、使用方法及其在内存操作中的重要作用,被誉为程序员手中的“内存操控魔法棒”。本书适合C语言初学者及希望深化理解指针机制的开发者阅读。