当前位置：首页 > news >正文

【C语言】数据指针地址的取值、赋值、自增操作避坑

news 2025/11/10 10:38:50

【C语言】数据指针的取值、赋值、自增操作避坑

文章目录

指针地址
指针自增
指针取值、赋值
附录：压缩字符串、大小端格式转换
- 压缩字符串
- - 浮点数
  - 压缩Packed-ASCII字符串
- 大小端转换
- - 什么是大端和小端
  - 数据传输中的大小端
  - 总结
  - 大小端转换函数

指针地址

请看下列代码：

#include<stdio.h>
#include<stdint.h>
#include<string.h>
#include <stdio.h>
#include <string.h>
uint8_t buf[10]={0x3F,0xaa,0x3E,0xbb,0xAA,0x3F,0xaa,0x3E,0xbb,0xAA};int main()
{void * p=&buf[0];uint8_t* p0=p;uint16_t* p1=p;uint32_t* p2=p;float * p3 =p;uint8_t i=0;for(i=0;i<10;i++){printf("%u ",&buf[i]);}printf("\n");printf("p:%u p0:%u p1:%u p2:%u p3:%u \n",p,p0,p1,p2,p3);p++;p0++;p1++;p2++;p3++;printf("p:%u p0:%u p1:%u p2:%u p3:%u \n",p,p0,p1,p2,p3);printf("%x\n",(uint16_t)*p0);printf("%x\n",*(uint16_t*)p0);return 0;
}

先不看答案先思考：

已知buf的地址为4206608
那么这几个printf的输出分别是哪些数
默认为小端格式

如果你能完全搞懂那么就没必要继续往下看了

如果不明白指针是什么意思那么请先去学指针

输出结果是：

4206608 4206609 4206610 4206611 4206612 4206613 4206614 4206615 4206616 4206617 
p:4206608 p0:4206608 p1:4206608 p2:4206608 p3:4206608 
p:4206609 p0:4206609 p1:4206610 p2:4206612 p3:4206612 
aa
3eaa

指针自增

除了void类型其他的指针地址都有自己的类型而不同的类型对应的数据结构大小也不一样

void指针可以单纯表示地址其自增时地址+1

uint8_t类型大小也是1字节所以自增地址+1
uint16_t类型大小 2字节所以自增地址+2
uint32_t类型大小4字节自增地址+4
float类型大小4字节自增地址+4

所以得到：
自增前后的地址为：

p:4206608 p0:4206608 p1:4206608 p2:4206608 p3:4206608 
p:4206609 p0:4206609 p1:4206610 p2:4206612 p3:4206612

指针取值、赋值

经过上一次的自增p0的地址为4206609
在buf中对应的是0xaa
对于取值(uint16_t)*p0其逻辑为先取值再转为uint16_t

所以是先得到uint8_t类型的0xaa 然后再做赋值操作得到uint16_t类型的0x00aa

对于取值*(uint16_t*)p0 其逻辑为先转为uint16_t*类型的指针地址再取值
在转为uint16_t*类型的指针地址后其地址对应的数为uint16_t类型的0x3eaa 取值后自然就是0x3eaa

附录：压缩字符串、大小端格式转换

压缩字符串

首先HART数据格式如下：
在这里插入图片描述

重点就是浮点数和字符串类型
Latin-1就不说了基本用不到

浮点数

浮点数里面如 0x40 80 00 00表示4.0f

在HART协议里面浮点数是按大端格式发送的就是高位先发送低位后发送

发送出来的数组为：40,80,00,00

但在C语言对浮点数的存储中是按小端格式来存储的也就是40在高位 00在低位
浮点数：4.0f
地址0x1000对应00
地址0x1001对应00
地址0x1002对应80
地址0x1003对应40

若直接使用memcpy函数则需要进行大小端转换否则会存储为：
地址0x1000对应40
地址0x1001对应80
地址0x1002对应00
地址0x1003对应00

大小端转换：

void swap32(void * p)
{uint32_t *ptr=p;uint32_t x = *ptr;x = (x << 16) | (x >> 16);x = ((x & 0x00FF00FF) << 8) | ((x >> 8) & 0x00FF00FF);*ptr=x;
}

压缩Packed-ASCII字符串

本质上是将原本的ASCII的最高2位去掉然后拼接起来比如空格(0x20)
四个空格拼接后就成了
1000 0010 0000 1000 0010 0000
十六进制：82 08 20
对了一下表 0x20之前的识别不了
也就是只能识别0x20-0x5F的ASCII表
在这里插入图片描述

压缩/解压函数后面再写：

//传入的字符串和数字必须提前声明 且字符串大小至少为str_len 数组大小至少为str_len%4*3 str_len必须为4的倍数
uint8_t Trans_ASCII_to_Pack(uint8_t * str,uint8_t * buf,const uint8_t str_len)
{if(str_len%4){return 0;}uint8_t i=0;memset(buf,0,str_len/4*3);	  for(i=0;i<str_len;i++){if(str[i]==0x00){str[i]=0x20;}}for(i=0;i<str_len/4;i++){buf[3*i]=(str[4*i]<<2)|((str[4*i+1]>>4)&0x03);buf[3*i+1]=(str[4*i+1]<<4)|((str[4*i+2]>>2)&0x0F);buf[3*i+2]=(str[4*i+2]<<6)|(str[4*i+3]&0x3F);}return 1;
}//传入的字符串和数字必须提前声明 且字符串大小至少为str_len 数组大小至少为str_len%4*3 str_len必须为4的倍数
uint8_t Trans_Pack_to_ASCII(uint8_t * str,uint8_t * buf,const uint8_t str_len)
{if(str_len%4){return 0;}uint8_t i=0;memset(str,0,str_len);for(i=0;i<str_len/4;i++){str[4*i]=(buf[3*i]>>2)&0x3F;str[4*i+1]=((buf[3*i]<<4)&0x30)|(buf[3*i+1]>>4);str[4*i+2]=((buf[3*i+1]<<2)&0x3C)|(buf[3*i+2]>>6);str[4*i+3]=buf[3*i+2]&0x3F;}return 1;
}

大小端转换

在串口等数据解析中难免遇到大小端格式问题

什么是大端和小端

所谓的大端模式，就是高位字节排放在内存的低地址端，低位字节排放在内存的高地址端。

所谓的小端模式，就是低位字节排放在内存的低地址端，高位字节排放在内存的高地址端。

简单来说：大端——高尾端，小端——低尾端

举个例子，比如数字 0x12 34 56 78在内存中的表示形式为：

1)大端模式：

低地址 -----------------> 高地址

0x12 | 0x34 | 0x56 | 0x78

2)小端模式：

低地址 ------------------> 高地址

0x78 | 0x56 | 0x34 | 0x12

可见，大端模式和字符串的存储模式类似。

数据传输中的大小端

比如地址位、起止位一般都是大端格式
如：
起始位：0x520A
则发送的buf应为{0x52,0x0A}

而数据位一般是小端格式（单字节无大小端之分）
如：
一个16位的数据发送出来为{0x52,0x0A}
则对应的uint16_t类型数为： 0x0A52

而对于浮点数4.0f 转为32位应是：
40 80 00 00

以大端存储来说发送出来的buf就是依次发送 40 80 00 00

以小端存储来说则发送 00 00 80 40

由于memcpy等函数是按字节地址进行复制其复制的格式为小端格式所以当数据为小端存储时不用进行大小端转换
如：

uint32_t dat=0;
uint8_t buf[]={0x00,0x00,0x80,0x40};memcpy(&dat,buf,4);float f=0.0f;f=*((float*)&dat); //地址强转printf("%f",f);

或更优解：

   uint8_t buf[]={0x00,0x00,0x80,0x40};   float f=0.0f;memcpy(&f,buf,4);

而对于大端存储的数据（如HART协议数据全为大端格式）其复制的格式仍然为小端格式所以当数据为小端存储时要进行大小端转换
如：

uint32_t dat=0;
uint8_t buf[]={0x40,0x80,0x00,0x00};memcpy(&dat,buf,4);float f=0.0f;swap32(&dat); //大小端转换f=*((float*)&dat); //地址强转printf("%f",f);

或：

uint8_t buf[]={0x40,0x80,0x00,0x00};memcpy(&dat,buf,4);float f=0.0f;swap32(&f); //大小端转换printf("%f",f);

或更优解：

uint32_t dat=0;
uint8_t buf[]={0x40,0x80,0x00,0x00};float f=0.0f;dat=(buf[0]<<24)|(buf[0]<<16)|(buf[0]<<8)|(buf[0]<<0)f=*((float*)&dat);

总结

固若数据为小端格式则可以直接用memcpy函数进行转换否则通过移位的方式再进行地址强转

对于多位数据比如同时传两个浮点数则可以定义结构体之后进行memcpy复制（数据为小端格式）

对于小端数据直接用memcpy写入即可若是浮点数也不用再进行强转

对于大端数据如果不嫌麻烦或想使代码更加简洁（但执行效率会降低）也可以先用memcpy写入结构体之后再调用大小端转换函数但这里需要注意的是结构体必须全为无符号整型浮点型只能在大小端转换写入之后再次强转若结构体内采用浮点型则需要强转两次

所以对于大端数据推荐通过移位的方式来进行赋值然后再进行个别数的强转再往通用结构体进行写入

多个不同变量大小的结构体要主要字节对齐的问题
可以用#pragma pack(1) 使其对齐为1
但会影响效率

大小端转换函数

直接通过对地址的操作来实现传入的变量为32位的变量
中间变量ptr是传入变量的地址

void swap16(void * p)
{uint16_t *ptr=p;uint16_t x = *ptr;x = (x << 8) | (x >> 8);*ptr=x;
}void swap32(void * p)
{uint32_t *ptr=p;uint32_t x = *ptr;x = (x << 16) | (x >> 16);x = ((x & 0x00FF00FF) << 8) | ((x >> 8) & 0x00FF00FF);*ptr=x;
}void swap64(void * p)
{uint64_t *ptr=p;uint64_t x = *ptr;x = (x << 32) | (x >> 32);x = ((x & 0x0000FFFF0000FFFF) << 16) | ((x >> 16) & 0x0000FFFF0000FFFF);x = ((x & 0x00FF00FF00FF00FF) << 8) | ((x >> 8) & 0x00FF00FF00FF00FF);*ptr=x;
}