C语言详解指针(指针海洋的探索,将传值与传址刻在心里)

简介: C语言详解指针(指针海洋的探索,将传值与传址刻在心里)

一、指针的概念

要知道指针的概念,要先了解变量在内存中如何存储的。在存储时,内存被分为一块一块的。每一块都有一个特有的编号。而这个编号可以暂时理解为指针,就像酒店的门牌号一样。

1.1内存与地址

在讲内存和地址之前,我们想有个⽣活中的案例:

假设你要去酒店,酒店有100个房间,但是房间没有编号,你的⼀个朋友来找你玩,如果他想要找到你,就得一个一个去找,这样的效率是很低的,那我们给定每个房间编号

⼀楼:101,102,103...

⼆楼:201,202,203....

...

你的朋友得到房间号,就可以快速找到你的房间,找到你。

如果把上面的例子对找到计算机中:

如: 你的朋友 就相当于计算器

        而你就是房间(地址)的内存了

        101 102 103  就相当于地址          

在计算机中我们把内存单元的编号也称为地址。C语言中给地址起了新的名字叫:指针 

例子:

void main()
 
{
 
          int x = 1, int y = 2;
 
} 

这段代码非常简单,就是两个变量的声明,分别赋值了 1、2。我们把内存当做一个酒店,而每个房间就是一块内存。那么“int x = 1;”和“int y = 2;”的实际含义如下:

去酒店订了两个房间,门牌号暂时用 px、py 表示
让 1 住进 px,让 2 住进 py
其中门牌号就是 px、py 就是变量的地址
x 和 y 在这里可以理解为具体的房间,房间 x 的门牌号(地址)是 px,房间 y 的门牌号(地址)是 py。而 1和 2,通过 px、py 两个门牌,找到房间,住进 x、y。

二、变量的指针与指针变量

变量的指针就是变量的存储地址,指针变量就是存储指针的变量。

2.1、指针变量的定义及使用

1、指针变量的定义

指针变量的定义形式如:数据类型 *指针名;例如:

//分别定义了 int、float、char 类型的指针变量

int *x;

float *f;

char *ch;

这里的指针变量是x,f,ch,并非  *x  ,  *f,  *ch.

数据名为int* , float*, char*

2、指针变量的使用

我们要怎样取地址呢?这就要用到——取地址运算符& 和 指针运算符*(间接寻址符)

取地址运算符&:单目运算符&是用来取操作对象的地址。例:&i 为取变量 i 的地址。对于常量表达式、寄存器变量不能取地址(因为它们存储在存储器中,没有地址)。

指针运算符*(间接寻址符):与&为逆运算,作用是通过操作对象的地址,获取存储的内容。例:x = &i,x 为 i 的地址,*x 则为通过 i 的地址,获取 i 的内容。

int main() {
 
    int a = 10;
    //输入一个整型变量a,变量的值为10
    int* pa = &a;
    //输入一个整型的指针变量pa来接收存放a的地址
    printf("%d",*pa);
    //(*)表示对pa存放地址的解引用
    return 0;
}

2.2 指针变量的大小

前⾯的内容我们了解到,32位机器假设有32根地址总线,每根地址线出来的电信号转换成数字信号后是1或者0,那我们把32根地址线产生的2进制序列当做⼀个地址,那么⼀个地址就是32个bit位,需要4 个字节才能存储。

如果指针变量是⽤来存放地址的,那么指针变的大小就得是4个字节的空间才可以。

同理64位机器,假设有64根地址线,⼀个地址就是64个⼆进制位组成的⼆进制序列,存储起来就需要 8个字节的空间,指针变的大小就是8个字节。

#include <stdio.h>
//指针变量的⼤⼩取决于地址的大小
//32位平台下地址是32个bit位(即4个字节)
//64位平台下地址是64个bit位(即8个字节)
int main()
{
printf("%zd\n", sizeof(char *));
printf("%zd\n", sizeof(short *));
printf("%zd\n", sizeof(int *));
printf("%zd\n", sizeof(double *));
return 0;
}

怎么回事呢?想必你也发现些许奥秘,没错,对于指针来说,指针变量的大小与类型无关、只要指针类型的变量,在相同的平台下,大小都是相同的。

2.3、指针+-整数

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

让我们打印一下吧!!!

我们可以看得出来 ,char* 类型的指针变量+1跳过1个字节, int* 类型的指针变量+1跳过了4个字节。 这就是指针变量的类型差异带来的变化。

结论:指针的类型决定了指针向前或者向后⾛⼀步有多⼤(距离)。

 

2.4、void*指针

在指针类型中有⼀种特殊的类型是 void* 类型的,可以理解为无具体类型的指针(或者叫泛型指

针),这种类型的指针可以⽤来接受任意类型地址。但是也有局限性, void* 类型的指针不能直接进 行指针的+-整数和解引用的运算。

我们来看一下这个代码:

#include <stdio.h>
int main()
{
    int a = 10;
    int* pa = &a;
    char* pc = &a;
    
    return 0;
}

显示从int*到char*的类型不兼容,编译器会给一个报错,用void*则不会出现这个问题

#include <stdio.h>
int main()
{
    int a = 10;
    void* pa = &a;
    void* pc = &a;
    
    return 0;
}

这里我们看到,void*可以用来接收不同类型的指针,但是注意的是void*不能用来指针的运算。

三、指针的运算

指针的基本运算有三种,分别是:

指针+- 整数

指针-指针

指针的关系运算

1、指针+- 整数

因为数组在内存中是连续存放的,只要知道第⼀个元素的地址,顺藤摸⽠就能找到后⾯的所有元素。

#include <stdio.h>
//指针+- 整数
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(i=0; i<sz; i++)
{
printf("%d ", *(p+i));     //p+i 这⾥就是指针+整数
}
return 0;
}

2、指针-指针

//指针-指针
#include <stdio.h>
int my_strlen(char *s)
{
char *p = s;
//每次++,到达下一个元素,到最后一个为NULL时,p指向c
while(*p != '\0' )
p++;
return p-s;     
//返回地址的差值,因为是char*类型,每个地址间跳过一个字节,所以返回的
 
}
int main( )
{
printf("%d\n", my_strlen("abc"));
return 0;
}

3、指针的关系运算

//指针的关系运算
#include <stdio.h>
 
 
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;
}

6. 野指针

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

6.1、野指针成因

指针未初始化:
#include <stdio.h>
int main()
{
 
int *p;//局部变量指针未初始化,默认为随机值
*p = 20;
 
return 0;
 
}
指针越界访问
#include <stdio.h>
int main()
{
int arr[10] = {0};
int *p = &arr[0];
int i = 0;
for(i=0; i<=11; i++)
{
//当指针指向的范围超出数组arr的范围时,p就是野指针
*(p++) = i;
}
return 0;
}
指针指向的空间释放
#include <stdio.h>
int* test()
{
int n = 100;
return &n;
}
 
int main()
{
int*p = test();
printf("%d\n", *p);
return 0;
}

那我们如何规避野指针的出现呢

6.2、如何规避野指针

指针初始化,如果我们明确指针的指向的话,该指哪就指向哪;当我们不知道指向哪时, 可以给指针赋值NULL. NULL 是C语⾔中定义的⼀个标识符常量,值是0;0也是地址,这个地址是⽆法使⽤的,读写该地址 会报错。

#include <stdio.h>
int main()
{
int num = 10;
int*p1 = &num
int*p2 = NULL;
 
return 0;
}

6.3、注意指针不要越界

⼀个程序向内存申请了哪些空间,通过指针也就只能访问哪些空间,不能超出范围访问,超出了就是 越界访问。

6.4、当指针不再使用时,可以将其置为NULL,指针使用前,判断其有效性

当指针变量指向⼀块区域的时候,我们可以通过指针访问该区域,后期不再使⽤这个指针访问空间的 时候,我们可以把该指针置为NULL。因为约定俗成的⼀个规则就是:只要是NULL指针就不去访问, 同时使⽤指针之前可以判断指针是否为NULL。

我们可以把指针想为野狗,不管理的野狗是非常危险的,我们可以将野狗栓在一棵树(NULL),就相对安全了;

6.2、assert函数

assert.h 头文件定义了宏 assert() ,⽤于在运行时确保程序符合指定条件,如果不符合,就报

错终止运行。这个宏常常被称为“断⾔”。

assert(p != NULL );

运行这个语句的时候,判断p是否为空,如果不为空则,程序继续运行,如果为空,则终止程序,并给出错误的信息提示。

四、多级指针及指针数组

(1)多级指针

指针变量作为一个变量也有自己的存储地址,而指向指针变量的存储地址就被称为指针的指针,即二级指针。依次叠加,就形成了多级指针。

int p = 10;
//设置一个变量为p
int* pc = &p;
//取p的地址存进pc
int** pt = &pc;
//取pc的地址存进pt,这里的pt为二级指针

先用一个简单的数组来举例:

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

我们可以看出二维数组地址的运用,可以看作一维数组;以此来推断,面对多维数组地址的运用时,我们不必害怕,可以当作一维数组

4.3、指向函数的指针

C 语言中,函数不能嵌套定义,也不能将函数作为参数传递。但是函数有个特性,即函数名为该函数的入口地址。我们可以定义一个指针指向该地址,将指针作为参数传递。

对于函数参数传递时,如果是传址函数时,则可以改变该地址的函数值;如为传值,则不然;

#include<stdio.h>
 
void comp_int(int*comp) {
  *comp = 10;
}
 
int main()
{
  int a = 10;
  int b = 20;
  comp_int(&b);
  if (a == b) {
    printf("相等");
  }
  return 0;
}

这里的输出为:相等,则我们可以通过传址改该地址的值;

五、计算器(转移表)的使用

1、计算器的实现(switch)

对于一个计算器,需要有最基础的(加减乘除),来人,上代码:

这时候有人就会觉得这个代码有点冗长,说:小伞,小伞有没有办法,能将代码变得便洁吗?

那当然是有的呀!

#define _CRT_SECURE_NO_WARNINGS
 
#include<stdio.h>
 
int add(int x, int y) {
  return x + y;
}
int sub(int x, int y) {
  return x - y;
}
int mul(int x, int y) {
  return x * y;
}
int div(int x, int y) {
  return x / y;
}
 
int main() {
  int a = 0;
  int x, y;
  int ret;
  do
  {
    printf("*************************\n");
    printf("    1:add     2:sub      \n");
    printf("    3:mul     4:div      \n");
    printf("    0:exit               \n");
    printf("*************************\n");
    printf("请选择:");
    scanf("%d", &a);
    switch (a)
    {
    case 1:
      printf("输⼊操作数:");
      scanf("%d %d", &x, &y);
      ret = add(x, y);
      printf("ret = %d\n", ret);
      break;
    case 2:
      printf("输⼊操作数:");
      scanf("%d %d", &x, &y);
      ret = sub(x, y);
      printf("ret = %d\n", ret);
      break;
    case 3:
      printf("输⼊操作数:");
      scanf("%d %d", &x, &y);
      ret = mul(x, y);
      printf("ret = %d\n", ret);
      break;
    case 4:
      printf("输⼊操作数:");
      scanf("%d %d", &x, &y);
      ret = div(x, y);
      printf("ret = %d\n", ret);
      break;
    case 0:
      printf("退出程序\n");
      break;
    default:
      printf("选择错误\n");
      break;
    }
  } while (a);
  return 0;
}

如果我们使用switch语句来实现这样一个简易的计算器我们会发现,每当我要添加一个功能的时候。都需要增加一个case语句,比如我要增加一个&运算,我得再加上一个case语句。因此我们可以使用函数指针数组(转移表)来实现,会简易很多。

什么是转移表?

其实很简单,它所指的就是运用函数指针数组以数组方式去调用里面的函数,从而在某些情况下替代冗长的switch函数,就叫转移表。

单纯的文字说明实在有些单调,这里通过模拟实现计算器来进一步解释说明转移表。

上代码:

#include <stdio.h>
int add(int a, int b)
{
  return a + b;
}
int sub(int a, int b)
{
  return a - b;
}
int mul(int a, int b)
{
  return a * b;
}
int div(int a, int b)
{
  return a / b;
}
int main()
{
  int x, y;
  int input = 1;
  int ret = 0;
  //p[]={add,sub,mul,div}
  //这里我们想要将函数的地址存进来
  //int(*p[])(int,int)
  //返回类型   函数指针  指向函数的参数
  int(*p[5])(int , int )= { 0, add, sub, mul, div }; //转移表
  //函数指针的数组     下标    0   1    2    3    4
  do
  {
    printf("*************************\n");
    printf(" 1:add 2:sub \n");
    printf(" 3:mul 4:div \n");
    printf(" 0:exit \n");
    printf("*************************\n");
    printf("请选择:");
    scanf("%d", &input);
    if ((input <= 4 && input >= 1))
    {
      printf("输⼊操作数:");
      scanf("%d %d", &x, &y);
      ret = (*p[input])(x, y); //
      printf("ret = %d\n", ret);
    }
    else if (input == 0)
    {
      printf("退出计算器\n");
    }
    else
    {
      printf("输⼊有误\n");
    }
  } while (input);
     return 0;
}

对于指针的学习还很多,今天先讲到这里了,点点赞吧!!!



相关文章
|
29天前
|
存储 C语言
【C语言篇】深入理解指针3(附转移表源码)
【C语言篇】深入理解指针3(附转移表源码)
33 1
|
9天前
|
C语言
【c语言】指针就该这么学(1)
本文详细介绍了C语言中的指针概念及其基本操作。首先通过生活中的例子解释了指针的概念,即内存地址。接着,文章逐步讲解了指针变量的定义、取地址操作符`&`、解引用操作符`*`、指针变量的大小以及不同类型的指针变量的意义。此外,还介绍了`const`修饰符在指针中的应用,指针的运算(包括指针加减整数、指针相减和指针的大小比较),以及野指针的概念和如何规避野指针。最后,通过具体的代码示例帮助读者更好地理解和掌握指针的使用方法。
32 0
|
8天前
|
C语言
【c语言】指针就该这么学(3)
本文介绍了C语言中的函数指针、typedef关键字及函数指针数组的概念与应用。首先讲解了函数指针的创建与使用,接着通过typedef简化复杂类型定义,最后探讨了函数指针数组及其在转移表中的应用,通过实例展示了如何利用这些特性实现更简洁高效的代码。
11 2
|
8天前
|
C语言
如何避免 C 语言中的野指针问题?
在C语言中,野指针是指向未知内存地址的指针,可能引发程序崩溃或数据损坏。避免野指针的方法包括:初始化指针为NULL、使用完毕后将指针置为NULL、检查指针是否为空以及合理管理动态分配的内存。
|
8天前
|
C语言
C语言:哪些情况下会出现野指针
C语言中,野指针是指指向未知地址的指针,通常由以下情况产生:1) 指针被声明但未初始化;2) 指针指向的内存已被释放或重新分配;3) 指针指向局部变量,而该变量已超出作用域。使用野指针可能导致程序崩溃或不可预测的行为。
|
14天前
|
存储 C语言
C语言32位或64位平台下指针的大小
在32位平台上,C语言中指针的大小通常为4字节;而在64位平台上,指针的大小通常为8字节。这反映了不同平台对内存地址空间的不同处理方式。
|
14天前
|
存储 算法 C语言
C语言:什么是指针数组,它有什么用
指针数组是C语言中一种特殊的数据结构,每个元素都是一个指针。它用于存储多个内存地址,方便对多个变量或数组进行操作,常用于字符串处理、动态内存分配等场景。
|
14天前
|
存储 C语言
C语言指针与指针变量的区别指针
指针是C语言中的重要概念,用于存储内存地址。指针变量是一种特殊的变量,用于存放其他变量的内存地址,通过指针可以间接访问和修改该变量的值。指针与指针变量的主要区别在于:指针是一个泛指的概念,而指针变量是具体的实现形式。
|
15天前
|
C语言
C语言指针(3)
C语言指针(3)
10 1
|
15天前
|
C语言
C语言指针(2)
C语言指针(2)
11 1