【C语言】十六进制、二进制、字节、位
文章目录
- @[TOC](文章目录)
- 前言
- 一、十六进制、二进制、字节、位
- 二、变量、指针、指针变量
- 三、数组与指针
- 四、指针自加运算
- 五、二维数组与指针
- 六、指向指针的指针
- 七、指针变量作为函数形参
- 八、函数指针
- 九、函数指针数组
- 十、参考文献
- 总结
文章目录
- @[TOC](文章目录)
- 前言
- 一、十六进制、二进制、字节、位
- 二、变量、指针、指针变量
- 三、数组与指针
- 四、指针自加运算
- 五、二维数组与指针
- 六、指向指针的指针
- 七、指针变量作为函数形参
- 八、函数指针
- 九、函数指针数组
- 十、参考文献
- 总结
前言
使用工具：
1.控制器：STM32F103C8T6
2.仿真器：STLINK
3.C Primer Plus 第六版-1
提示：以下是本篇文章正文内容，下面案例可供参考
一、十六进制、二进制、字节、位
u16 A_Parameter[10],B_Parameter[10],Flash_Parameter[10]; //
在C语言或类似的环境中，u16 通常被定义为 unsigned short，这意味着它是一个无符号的16位整型数据。由于一个字节包含8位，因此 u16 类型的数据占用2个字节。
对于数组 u16 A_Parameter[10]，它包含了10个 u16 类型的元素。每个元素占用2个字节，因此整个数组占用的字节数为：
10 元素×2 字节/元素=20 字节
所以，u16 A_Parameter[10] 占用了20个字节。
A_Parameter[0] 是数组 A_Parameter 的第一个元素，其类型为 u16，即 unsigned short。由于 u16 是一个16位的无符号整型，它占用2个字节。
因此，A_Parameter[0] 占用2个字节。
#define FLASH_SAVE_ADDR 0X0800E000
通过仿真器回读芯片FLASH中0X0800E000地址
十六进制表示
31 00 00 00 03 00 04 00
A_Parameter[0] 占据两个字节，
一个字节占据8位，
十六进制表示0x31 00，
二进制表示0011 0001 0000 0000，
按位表示共有十六个0和1的位组成
二、变量、指针、指针变量
使用”&”来获取普通变量的地址
&变量名取得变量地址后就可以赋值给指针变量
这个代码里，我们定义了一个变量a, 定义了一个指针变量p。
我们通过运算符&把变量a的内存地址赋值给变量p，所以p指向了变量a的内存存储地址。
通过指针变量来改变变量a的值，因为指针变量p指向的是变量a的地址，所以改变指针变量p指向内存地址的数据就可以改变变量a的值。
unsigned char a ;//
unsigned char *p ;//
void Flash_Write(void)
{
static unsigned int date=0;//¾²Ì¬Êý¾Ý£¬²»Ë溯Êý½øÈë°ÑÊý¾ÝÇå³ý
if(++date==65535)date=0;//Êý¾Ý×Ô¼Ó
B_Parameter[0]=M1.speed;//M1.speed//date
B_Parameter[1]=M2.speed;
B_Parameter[2]=3;
B_Parameter[3]=4;
printf("Êý¾ÝÀàÐ͵ĴóС\r\n");
printf("char=%d,int=%d,float=%d,double=%d\r\n"
,sizeof((unsigned char)B_Parameter[0])\
,sizeof((unsigned int)B_Parameter[1])\
,sizeof((float)B_Parameter[2])\
,sizeof((double)B_Parameter[3]));
printf("\r\n");
a=10;
p=&a;//È¡µØÖ·
printf("±äÁ¿aµÄµØÖ·\r\n");
printf("&a=0x%x\r\n",&a);
printf("p=0x%x\r\n",p);
printf("&p=0x%x\r\n",&p);
printf("\r\n");
printf("±äÁ¿aµÄÖµ\r\n");
printf("a=%d\r\n",a);
printf("*p=%d\r\n",*p);
printf("\r\n");
printf("ͨ¹ýÖ¸Õë±äÁ¿¸Ä±ä±äÁ¿aµÄÖµ\r\n");
*p=11;
printf("a=%d\r\n",a);
printf("*p=%d\r\n",*p);
printf("\r\n");
printf("ͨ¹ýÄÚ´æµØÖ·¸Ä±ä±äÁ¿aµÄÖµ\r\n");
*(unsigned int *)0x200005ac=12;
printf("a=%d\r\n",a);
printf("*p=%d\r\n",*p);
printf("\r\n");
STMFLASH_Write(FLASH_SAVE_ADDR,(u16*)B_Parameter,4);
}
三、数组与指针
buff默认的是数组下标为0元素的存储地址，buff和&buff[0]是同一个内存地址，只是写法不一样
unsigned char buff[5]={1,2,3,4,5};
unsigned char 表示占用一个字节，即buff数组中所有成员各占一个字节，如buff0]=0x01，占用一个字节
unsigned char buff[5]={1,2,3,4,5};
unsigned char *p1;
unsigned char *p2;
p1=buff;
p2=&buff[0];
printf("buff=0x%x\r\n",buff);
printf("&buff=0x%x\r\n",&buff[0]);
printf("p1_addr=0x%x\r\n",p1);
printf("p2_addr=0x%x\r\n",p2);
printf("\r\n");
printf("buff[0]=%d\r\n",buff[0]);
printf("*p1=%d\r\n",*p1);
printf("*p2=%d\r\n",*p2);
四、指针自加运算
普通变量加减的是数值，而指针变量加减的是地址
首先，代码打印出数组buff每个元素的地址和值。
然后，指针p1被初始化为指向数组的第一个元素（&buff[0]）。
接着，通过递增指针p1，代码遍历数组的每个元素，并打印出每个元素的地址和值。
#include <stdio.h>
int main() {
unsigned char buff[5] = {1, 2, 3, 4, 5};
unsigned char *p1;
// 打印数组每个元素的地址和值
printf("&buff[0]=0x%x buff[0]=%d\r\n", &buff[0], buff[0]);
printf("&buff[1]=0x%x buff[1]=%d\r\n", &buff[1], buff[1]);
printf("&buff[2]=0x%x buff[2]=%d\r\n", &buff[2], buff[2]);
printf("&buff[3]=0x%x buff[3]=%d\r\n", &buff[3], buff[3]);
printf("&buff[4]=0x%x buff[4]=%d\r\n", &buff[4], buff[4]);
p1 = &buff[0]; // 指针p1指向数组的第一个元素
// 使用指针遍历数组
printf("p1=0x%x *p1=%d\r\n", p1, *p1);
p1++;
printf("p1=0x%x *p1=%d\r\n", p1, *p1);
p1++;
printf("p1=0x%x *p1=%d\r\n", p1, *p1);
p1++;
printf("p1=0x%x *p1=%d\r\n", p1, *p1);
p1++;
printf("p1=0x%x *p1=%d\r\n", p1, *p1);
printf("\r\n");
return 0;
}
五、二维数组与指针
首先，代码打印出二维数组buff2每个元素的地址和值。
然后，指针p1被初始化为指向数组的第一个元素（&buff2[0][0]）。
接着，通过递增指针p1，代码遍历数组的每个元素，并打印出每个元素的地址和值。
#include <stdio.h>
int main() {
unsigned char buff2[2][3] = {{1, 2, 3}, {4, 5, 6}};
unsigned char *p1;
printf("五、二维数组与指针\r\n");
p1 = &buff2[0][0];
// 打印数组每个元素的地址和值
printf("&buff2[0][0]=0x%x buff2[0][0]=%d\r\n", &buff2[0][0], buff2[0][0]);
printf("&buff2[0][1]=0x%x buff2[0][1]=%d\r\n", &buff2[0][1], buff2[0][1]);
printf("&buff2[0][2]=0x%x buff2[0][2]=%d\r\n", &buff2[0][2], buff2[0][2]);
printf("&buff2[1][0]=0x%x buff2[1][0]=%d\r\n", &buff2[1][0], buff2[1][0]);
printf("&buff2[1][1]=0x%x buff2[1][1]=%d\r\n", &buff2[1][1], buff2[1][1]);
printf("&buff2[1][2]=0x%x buff2[1][2]=%d\r\n", &buff2[1][2], buff2[1][2]);
printf("\r\n");
// 使用指针遍历数组
printf("p1=0x%x *p1=%d\r\n", p1, *p1);
p1++;
printf("p1=0x%x *p1=%d\r\n", p1, *p1);
p1++;
printf("p1=0x%x *p1=%d\r\n", p1, *p1);
p1++;
printf("p1=0x%x *p1=%d\r\n", p1, *p1);
p1++;
printf("p1=0x%x *p1=%d\r\n", p1, *p1);
p1++;
printf("p1=0x%x *p1=%d\r\n", p1, *p1);
printf("\r\n");
return 0;
}
六、指向指针的指针
指针变量分为存储地址和指向地址
a的初始值是*a，是10，存储地址是&a，是0x200005ac
p1的存储地址是&p1，是0x200005bc；指向地址是p1，是0x200005ac，是a的存储地址
p3的存储地址是&p3，是0x200005cc；指向地址是p3，是0x200005bc，是p1的存储地址
*p3是取p3的值，取0x200005bc这个地址的值，而这个地址的值是一个地址，是0x200005ac，是a的存储地址
**p3是取*p3的值，即取0x200005ac这个地址的值，是10
输出结果解释：
&a、&p1、&p3分别打印出变量a、指针p1、指针p3的内存地址。
a=10给变量a赋值。
p1=&a使指针p1指向变量a。
p3=&p1使指针p3指向指针p1。
接下来的几行打印出变量和指针的地址及它们所指向的值，展示了如何通过指针和指向指针的指针来访问和操作变量。
#include <stdio.h>
int main() {
unsigned char a;
unsigned char *p1;
unsigned char **p3;
printf("六、指向指针的指针变量\r\n");
printf("&a=%p\r\n", (void*)&a); // 打印变量a的地址
printf("&p1=%p\r\n", (void*)&p1); // 打印指针p1的地址
printf("&p3=%p\r\n", (void*)&p3); // 打印指针p3的地址
printf("\r\n");
a = 10;
p1 = &a;
p3 = &p1;
printf("&a=0x%x a=%d\r\n", &a, a); // 打印变量a的地址和值
printf("&p1=0x%x p1=0x%x\r\n", &p1, p1); // 打印指针p1的地址和值（即变量a的地址）
printf("&p3=0x%x p3=0x%x\r\n", &p3, p3); // 打印指针p3的地址和值（即指针p1的地址）
printf("*p1=%d\r\n", *p1); // 打印指针p1指向的值（即变量a的值）
printf("*p3=0x%x\r\n", *p3); // 打印指针p3指向的值（即指针p1的值，也就是变量a的地址）
printf("**p3=%d\r\n", **p3); // 打印指针p3指向的指针所指向的值（即变量a的值）
return 0;
}
七、指针变量作为函数形参
代码解释：
#include <stdio.h>：包含标准输入输出库，以便使用printf函数。
void TEST7(unsigned char *p4)：定义了一个函数TEST7，它接收一个指向unsigned char类型的指针p4作为参数。
在TEST7函数内部，*p4 = 5;语句将指针p4指向的值修改为5。
在main函数中，首先声明了一个unsigned char类型的变量a，并初始化为1。
TEST7(&a);调用TEST7函数，并将变量a的地址作为参数传递。这样，TEST7函数内的修改会影响到main函数中的a变量。
printf(“a=%d\r\n”, a);打印变量a的值，此时a的值已经被TEST7函数修改为5。
这段代码演示了如何通过指针参数在函数间共享和修改数据。
#include <stdio.h>
void TEST7(unsigned char *p4)
{
*p4 = 5;
}
int main() {
unsigned char a;
printf("七、指针变量作为函数参数 \r\n");
a = 1;
TEST7(&a);
printf("a=%d\r\n", a);
printf("\r\n");
return 0;
}
八、函数指针
定义函数指针：
unsigned char (*func)(unsigned char,unsigned char);
这行代码定义了一个函数指针func，它指向一个接受两个unsigned char类型参数并返回一个unsigned char类型结果的函数。
定义函数：
unsigned char TEST8(unsigned char v1,unsigned char v2)
{
return (v1+v2);
}
这行代码定义了一个函数TEST8，它接受两个unsigned char类型的参数v1和v2，并返回它们的和。
使用函数指针调用函数：
func = TEST8;
a = (*func)(1,2);
首先，将函数TEST8的地址赋给函数指针func。然后，通过函数指针func调用函数TEST8，并传递参数1和2。函数的结果被赋值给变量a。
打印结果：
printf("a=%d\r\n",a);
这行代码打印变量a的值，即函数TEST8的返回值。
#include <stdio.h>
unsigned char (*func)(unsigned char,unsigned char);
unsigned char TEST8(unsigned char v1,unsigned char v2)
{
return (v1+v2);
}
int main()
{
unsigned char a;
printf("函数指针示例\r\n");
func = TEST8;
a = (*func)(1,2);
printf("a=%d\r\n",a);
printf("\r\n");
return 0;
}
九、函数指针数组
定义函数指针数组：
void (*TEST9[3])()={func1,func2,func3};
这行代码定义了一个名为TEST9的函数指针数组，它包含3个元素，每个元素都是一个指向无参数、无返回值（void类型）函数的指针。数组在定义时就被初始化为包含func1、func2和func3这三个函数的地址。
定义函数：
void func1() { printf("func1 \r\n"); }
void func2() { printf("func2 \r\n"); }
void func3() { printf("func3 \r\n"); }
这三行代码定义了三个无参数、无返回值的函数func1、func2和func3，它们分别打印出各自的名称。
使用函数指针数组调用函数：
TEST9[0]();
TEST9[1]();
TEST9[2]();
这三行代码通过函数指针数组TEST9来调用func1、func2和func3这三个函数。数组的每个元素都是一个函数指针，通过在该指针后面加上()来调用对应的函数。
打印提示信息：
printf("¾Å¡¢º¯ÊýÖ¸ÕëÊý×é \r\n");
这行代码打印出一条提示信息，表明接下来将演示函数指针数组的使用。注意，这里的文本“¾Å¡¢”可能是某种特定编码下的字符，它在正常的ASCII或UTF-8编码下不会显示为预期的文本。在实际编程中，应使用可打印的ASCII或UTF-8字符来编写代码和注释。
#include <stdio.h>
void func1() { printf("func1 \r\n"); }
void func2() { printf("func2 \r\n"); }
void func3() { printf("func3 \r\n"); }
void (*TEST9[3])() = {func1, func2, func3};
int main() {
printf("函数指针数组示例 \r\n");
TEST9[0]();
TEST9[1]();
TEST9[2]();
return 0;
}
十、参考文献
位、字节、16进制
c语言指针用法及实际应用详解，通俗易懂超详细！
VSCode中C语言程序输出时，控制台出现中文乱码的问题
VSCode编译C语言代码
总结
本文仅仅简单介绍了【C语言】十六进制、二进制、字节、位验证，评论区欢迎讨论。
