C语言之指针篇

简介: C语言之指针篇



内存

在前面初始C语言(4)中我们详细的讲解了 内存知识,我们再次遇到指针,来简单回顾一下。

内存编号

内存的划分:一个内存单元是1个字节

为什么是1个字节,不是一个bite呢?

当一个内存单元是1个bite时,最小的变量char类型都需要8个bite位,int类型需要32个bite位。是非常浪费内存单元的,所以一个内存单元是合适就是一个字节。

内存的访问(内存编号的成因)

内存的访问需要内存编号(地址),那地址又是怎样产生的呢?地址线

在32位机器下,32个地址线,产生32个0/1的电信号。即一个地址。

一般,地址线产生电信号,电信号形成一个地址,直接找到一个内存单元(一个字节),无需存储。

若需要&取地址去存储地址,即32个比特位,4个字节来存储一个地址

根据上文,我们知道一个地址管理一个字节。32位机器下,总共可以管理2^32个字节的内存空间,是多大呢?4GB

总结(关系)

32个电信号------→1个地址/内存单元的编号(4个字节)------→1个内存单元(1个字节)

以上都是存在32位机器下,那么64位的机器下同理。

指针

指针是什么?

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

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

单元编号 == 地址 == C语言中也叫指针

取地址和指针变量

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

指针变量,用来存放地址的变量。(存放在指针中的值都被当成地址处理)。

我们可以通过&(取地址操作符)取出变量的内存起始地址,把地址可以存放到一个变量中,这个变量就是指针变量

&(取地址操作符),&a,取a变量中最小的地址存储道指针变量中。

#include<stdio.h>
int main()
{
  int a = 10;//是向内存的栈区空间申请了4个字节的空间这4个字节用来存放数值10
  int* p = &a;
  //这里我们对变量a,取出它的地址,可以使用&操作符。
  //将a的地址存放在p变量中,p就是一个之指针变量。
    &a;
    //&a,取a中最小的一个地址存放到p
  printf("%d\n", sizeof(&a));
  return 0;
}
#include<stdio.h>
int main()
{
  int* d = 10;//存放到指针变量中都会被当作是地址
  printf("%d", d);//所以打印的也是地址
  return 0;
}

指针的大小

X86

X64

指针变量是用来存放地址的
指针变量的大小,就取决于存放一个地址需要多大的空间
在32位的环境下:
一个地址大小是32bit位,需要4个字节。所以不管什么类型的指针变量,大小都是4个字节。
在64位的环境下:
一个地址大小是64bit位,需要8个字节。所以不管什么类型的指针变量,大小都是8个字节。
综上:指针大小在32位平台是4个字节,64位平台是8个字节。

总结理解的tips

  1. 内存被划分成一个个的内存单元,每个内存单元的大小是1个字节
  2. 每个字节的内存单元都有一个编号,这个编号就是地址,地址在C语言中称为指针
  3. 地址在存储的话,存放在指针变量中
  4. 每个内存单元都有一个唯一的地址来标识
  5. 存放在指针中的值都被当成地址处理
  6. 口有语说指针,就是指针变量,存放内存地址(指针)的变量
  7. &a取地址,拿a变量中最小的地址,即只有一个地址存放到指针变量。
  8. 在32位机器上地址的大小是4个字节,所以指针变量的大小也是4个字节。
  9. 在64位机器上地址的大小是8个字节,所以指针变量的大小也是8个字节。
  10. 无论指针变量的类型,里面存储都是最小的一个地址,所以大小都是4/8。

指针的表示

&——取地址操作符。
int* pa=&a;
*——pa是指针变量。
int——pa指向的是int类型的变量。
*pa
*——解应用操作符——通过地址找到地址所指向的对象。
#include<stdio.h>
int main()
{
  int a = 10;
  int* pa = &a;//取地址& 存到指针变量
  *pa = 20;//解应用* 修改值
  printf("%d", a);
  return 0;
}

指针类型

我们都知道,变量有不同的类型,整形,浮点型等。那指针有没有类型呢?准确来说:有的。

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

其实,char*类型的指针是为了存放char类型的变量的地址。short*类型的指针是为了存放short类型的变量的地址。int*类型的指针是为了存放int类型变量的地址。

指针类型的作用

上面我们讲到,无论那种类型的指针变量存放的都是最小单元的地址,都是4个/8个字节。那为什么不同意为一个指针类型呢?那指针类型 的意义是什么?

解应用

#include<stdio.h>
int main()
{
  int a = 0x11223344;
  int* pa = &a;
  *pa = 0;
  return 0;
}
//重点在调试的过程中观察内存的变化。
//因为能力有限,不能将调试的过程展现给大家,大家可以在VS上尝试自己调试。
//int* 解引用访问了4个字节。
#include<stdio.h>
int main()
{
  int a = 0x11223344;
  char* pa = &a;
  *pa = 0;
  printf("%d", a);
  return 0;
}
//重点在调试的过程中观察内存的变化。
//char* 解引用访问了1个字节

因为能力有限,不能将调试的过程给大家展现出来,大家可以自己在VS上调试。

重点在调试过程中内存的变化。

int*     解引用 访问了4个字节(改变了4个字节)

char*  解引用访问了1个字节 (改变了1个字节)

导致最后结果是不相同的。

所以,指针类型是有意义的,指针类型决定了指针进行解引用操作的时候,访问几个字节。

指针+-整数

#include<stdio.h>
int main()
{
  int a = 10;
  int* pa = &a;
  char* pc = &a;
  printf("%p\n", pa);
  printf("%p\n", pa+1);
  printf("%p\n", pc);
  printf("%p\n", pc+1);
  return 0;
}

指针类型是有意义的。

指正类型决定了指针+1/-1跳过几个字节。

int* 的指针+1,跳过4个字节。

char*的指针+1,跳过1个字节。

short*的指针+1,跳过2个字节。

double*的指针+1,跳过8个字节。

总结

#include<stdio.h>
int main()
{
  int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
  &a;//取地址
  char* pa
  short* pa
  int* pa
  double* pa
    printf("%d\n", a);
  return 0;
}
#include<stdio.h>
int main()
{
  int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
  int* pa = arr;
  int i = 0;
  for (i = 0; i<10; i++)
  {
    *pa = 0;
    pa++;
  }//全部修改为0
  for (i = 0; i < 10; i++)
  {
    printf("%d", arr[i]);
  }
  return 0;
}

指针类型是有意义的

未来访问时,可以选择合适的指针类型来访问。需要什么样的方式去访问,就用合适的指针类型来存储地址。

野指针

概念:野指针就是指针指向的位置是不可知的(随机的,不正确的,没有明确限制的)指针变量在定义时,如果未初始化,其值是随机的,指针变量的值是别的变量的地址,意味着指针指向了一个地址是不确定的变量,此时去解引用就是去访问了一个不确定的地址,所以结果是不可能的。

野指针成因

指针指向随便地址

#include<stdio.h>
int main()
{
  int* p = (int*)0x11223344;
  *p;
  return 0;
}

指针未初始化

#include<stdio.h>
int main()
{
  int* p;//局部变量指针未初始化,默认为随机值
  *p=10;
  return 0;
}

指针越界访问

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

指针指向的空间释放

#include<stdio.h>
int* test()
{
  int a = 10;
  return &a;
}//出了函数 &a就销毁了
int main()
{
  int* p = test();//野指针
  printf("%d", *p);
  return 0;
}

如何规避野指针

  1. 指针初始化
  2. 小心指针越界
  3. 指针指向空间释放,及时放置NULL。(避免返回局部变量的地址)
  4. 指针使用之前检查有效性。
#include<stdio.h>
int* test()
{
  int a = 10;
  return &a;
}
int main()
{
  int* p = test(NULL);
  printf("%d", *p);
  return 0;
}
#include <stdio.h>
int main()
{
  int *p = NULL;
  //....
  int a = 10;
  p = &a;
  if(p != NULL)
 {
    *p = 20;
 }
  return 0;
}
  • 如果有明确指针应该指向哪里,就初始化正确的地址。
  • 如果指针不明确指向或不知道初始化什么值,为了安全,初始化NULL。

(NULL是0,0作为地址时,这个地址用户程序时不能访问!)

指针运算

指针+-整数

//利用数组指针+-整数来遍历数组
#include<stdio.h>
int main()
{
  int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
  int* p = arr;
  int i = 0;
  for (i = 0; i < 10; i++)
  {
    printf("%d\n", *(p+i));
    
  }
  return 0;
}
//利用数组指针+-整数来遍历数组
#include<stdio.h>
int main()
{
  int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
  //              0,1,2,3,4,5,6,7,8,9
  int* p = arr;
  int i = 0;
  for (i = 0; i < 10; i++)
  {
    printf("%d\n", *(p+i));
    printf("%d\n", *(arr + i));
    printf("%d\n", arr[i]);
    printf("%d\n", i[arr]);
    //本质和底层逻辑:
    // 数组遍历元素都是根据(首地址+偏移量)解引用找到数组中的元素
    //p指向的是数组首元素
    //p+i 是数组中下标为i的元素的地址
    //p+i 起始时跳过了i*sizeof(int)个字节
  }
  return 0;
}
//arr——>p
//arr == p
//arr+i == p+i
//*(arr+i) == *(p+i) == arr[i]
//*(arr+i) == arr[i]
// //*(i+arr) == i[arr]
// [ ]下标应用操作符
// 3+5和5+3
// i[arr]=arr[i]

数组利用下标遍历数组元素本质:

均是拿到数组首元素地址,根据(首元素+偏移量)解引用找到数组中的元素。

 [ ]下标应用操作符:arr[i]=i[arr]

指针-指针

#include<stdio.h>
int main()
{
  int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
  printf("%d\n", arr[0] - arr[9]);
  printf("%d", arr[9] - arr[0]);
  return 0;
}

指针-指针的前提:两个指针指向同一块区域,指针类型是相同

指针-指针差值的绝对值:指针和指针之间的元素个数

关于模拟实现strlen的功能,我们学习了计数器和递归,在这里我们将用到指针运算的方法去实现strlen的功能。

#include<stdio.h>
size_t str( char* str)
{
  char* p = str;
  while (*str)
   //while(*str != '\0')
   //其实\0就是\ddd 所以\0就是0 while表达式的执行条件是真,为0时跳出括号。
  {
    str++;
  }
  return str - p;//地址
}
int main()
{
  char arr[] = "abcdef";
  size_t ret = str(arr);
  printf("%zd\n", ret);
  return 0;
}
//特殊注意不要将指针变量的类型搞错了

指针的关系运算

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

这段代码是怎样执行的呢?如下

这里我们就vp和&values[N_VALUES]指针间的关系,即指针和指正比较(= > < >= <=)等等

那我们换种写法呢?

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

这里有些友友会觉得太复杂了,那我们来简化一下。

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

虽然这样写很简单,实际上再绝大部分的编译器上是可以顺利完成任务的,然而我们还是应该避免这样写,因为标准不保证它可行

标准规定:

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

那为什么要这样规定呢?在后面学习C++其他的时候应该会解决的我们疑惑吧。

二级指针

指针变量也是变量,是变量就有地址,那指针变量的地址存放在哪里?这就是二级指针。

二级指针变量是存放一级指针变量的地址的。

#include<stdio.h>
int main()
{
  int a = 10;
  int* p = &a;//p是指针变量,一级指针变量
  int* * pp = &p;//pp是指针,二级指针变量
  return 0;
}

特别注意对指针变量的理解,当然还有三级,四级指针等等,那我们常用的就是一级二级指针。

*pp通过对pp中的地址进行解引用,这样找到的是p,pp其实访问的是p

**pp先通过*pp找到p,然后对p进行解引用操作,*p,那就找到了a

*pp--------→p   *p---------→a

**pp---------→a

#include<stdio.h>
int main()
{
  int a = 10;
  int * p = &a;
  int * * pp = &p;
  **pp = 20;
  printf("%d", a);
  return 0;
}

指针与数组

指针就是指针,指针变量就是一个变量,存放地址,指针变量的大小是4/8

数组就是数组,可以存放一组类型相同的元素,数组的大小是取决于元素的类型和个数

二者联系:数组的数组名是数组首元素的地址,地址是可以访问指针变量中。

关于数组名,我们再次复习一下

数组名表示首元素地址

sizeof(数组名),数组名单独放在sizeof内部,数组名表示整个数组,计算的是数组的大小,单位是字节。

&数组名,数组名表示整个数组,取出的是数组的地址,数组的地址和数组首元素的地址,值是一样的,但是类型和意义是不一样的。

#include<stdio.h>
int main()
{
  int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
  printf("%p\n", &arr);
  printf("%p\n", &arr + 1);
  //int* 跳过4个字节
  printf("%p\n", arr);
  printf("%p\n", arr + 1);
  printf("%p\n", &arr[0]);
  printf("%p\n", &arr[0]+1);
    printf("%d\n", sizeof(arr));
  return 0;
}

上面我们已经学习到数组名(首元素地址)和指针变量p(存放首元素地址)可以互换使用。

//arr——>p
//arr == p
//arr+i == p+i
//*(arr+i) == *(p+i) == arr[i]
//*(arr+i) == arr[i]
#include<stdio.h>
int main()
{
  int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
  int* p = arr;
  int i = 0;
  for (i = 0; i < 10; i++)
  {
    printf("%d\n", *(p + i));
    printf("%d\n", *(arr + i));
  }
  return 0;
}

特别提醒

p是一个指针变量可以++/--等操作。

arr是数组名,数组首元素地址,不可以这样操作。

#include<stdio.h>
int main()
{
  int arr[10]={0};
  int* p=arr;
  p++;
 //arr++❌
  return 0;
}

我们知道通过指针可以访问一个数组的元素,那我们是否写一个代码修改数组的元素和访问呢?

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

关于数组和指针的关系,我们已经有了非常清晰的认识。

指针数组

指针数组是指针还是数组?

答案:是数组。是存放指针的数组。

字符数组 —— 存放字符的数组

整型数组 —— 存放整型的数组

指针数组 —— 存放指针(地址)的数组

例如: char* arr[5];//存放字符指针的数组       double* arr2[4];//存放字符指针的数组

我们可以通过指针数组模拟一下二维数组

//使用指针数组,模拟一个二维数组
#include<stdio.h>
int main()
{
  int arr1[] = { 1,2,3,4,5 };
  int arr2[] = { 2,3,4,5,6 };
  int arr3[] = { 3,4,5,6,7 };
     //指针数组
  int* arr[] = { arr1,arr2,arr3 };
               //0   1     2
  int i = 0;
  int j = 0;
  for (i = 0; i < 3; i++)//找到首元素
  {
    for (j = 0; j < 5; j++)//遍历每一个数组的元素
    {
      printf("%d ", arr[i][j]);
    }
    printf("\n");
  }
  return 0;
}

✔✔✔✔✔✔✔最后,感谢大家的阅读,有任何错误和不足,欢迎大家指正!!!🙂

代码-----------------→【gitee:https://gitee.com/TSQXG

联系-----------------→【邮箱:2784139418@qq.com】

目录
相关文章
|
4天前
|
存储 C语言
C语言 — 指针进阶篇(下)
C语言 — 指针进阶篇(下)
11 0
|
4天前
|
存储 C语言 C++
C语言 — 指针进阶篇(上)
C语言 — 指针进阶篇(上)
5 0
|
10天前
|
存储 C语言
【C语言】深入解开指针(三)2
【C语言】深入解开指针(三)
|
10天前
|
存储 程序员 C语言
【C语言】深入解开指针(二)2
【C语言】深入解开指针(二)
【C语言】深入解开指针(二)2
|
11天前
|
存储 C语言
【C语言】深入解开指针(一)1
【C语言】深入解开指针(一)
|
12天前
|
C语言 索引
基于C语言的函数指针应用-消息命令处理框架
基于C语言的函数指针应用-消息命令处理框架
11 0
|
18天前
|
存储 人工智能 编译器
C语言指针详解
指针运算,指针和数组,二级指针
C语言指针详解
|
19天前
|
存储 C语言
C语言第二十四弹---指针(八)
C语言第二十四弹---指针(八)
|
19天前
|
编译器 C语言
C语言第十九弹---指针(三)
C语言第十九弹---指针(三)
|
24天前
|
存储 C语言
C语言中的指针变量
C语言中的指针变量
8 0