C语言指针操作字符数组demo

最新推荐文章于 2022-10-25 14:28:52 发布
最新推荐文章于 2022-10-25 14:28:52 发布
阅读量306 收藏
点赞数
分类专栏： C语言 文章标签： c语言 开发语言 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jackone12347/article/details/121138109
版权

C语言指针操作字符数组demo，本意是使用指针操作source，函数调用一次取16个字节，调用两次获取到整个数据。

char source[32] = {0};
int *header = (int *)source;
int *pos = (int *)source;

void print_value(int *arg0, int *arg1, int *arg2, int *arg3)
{
	if (  4 * (pos - header) >= 32)
		pos = header;
	*arg0 = *pos;
	pos++;
	*arg1 = *pos;
	pos++;
	*arg2 = *pos;
	pos++;
	*arg3 = *pos;
	pos++;

	printf("arg0:%x, arg1:%x, arg2:%x, arg3:%x\n", *arg0, *arg1, *arg2, *arg3);
}

int main(void) {
	memcpy(source, "11223344112233445566778855667788", 32);

	printf("sourceData is:\n");
	for (int i = 0; i < 32; i++)
	{
		printf("%x", source[i]);
	}
	printf("\n");

	printf("Result:\n");
	
	int arg0;
	int arg1;
	int arg2;
	int arg3;
	
	char data[32] = {0};
	for (int j = 0; j < 2; j++)
	{
		print_value(&arg0, &arg1, &arg2, &arg3);
	}

	printf("print again.\n");
	for (int j = 0; j < 2; j++)
	{
		print_value(&arg0, &arg1, &arg2, &arg3);
	}
}

运行结果：

$ ./test
sourceData is:
3131323233333434313132323333343435353636373738383535363637373838
Result:
arg0:32323131, arg1:34343333, arg2:32323131, arg3:34343333
arg0:36363535, arg1:38383737, arg2:36363535, arg3:38383737
print again.
arg0:32323131, arg1:34343333, arg2:32323131, arg3:34343333
arg0:36363535, arg1:38383737, arg2:36363535, arg3:38383737
$

===================================================
下面是稍微变化点的操作，
需求是这样的：操作RPMB的data_frame长度是512字节，写入数据时需要计算数据的hmac，但是计算hmac是从data_frame结构体去掉stuff和keymac后数据。

RPMB data_frame的结构体定义如下：

#define RPMB_SZ_STUFF		  196
#define RPMB_SZ_MAC		      32
#define RPMB_SZ_DATA		  256
#define RPMB_SZ_NONCE		  16
#define RPMB_SZ_COUNTER       4
#define RPMB_SZ_ADDRESS       2
#define RPMB_SZ_BLK_COUNT     2
#define RPMB_SZ_RESULT        2
#define RPMB_SZ_REQ_RESP      2
#define RPMB_SZ_RESERVED      4

#define HMAC_DATALEN 
#define HMAC_COUNT(x) (x + 1)

typedef struct {
  char Stuff[RPMB_SZ_STUFF];
  char KeyMac[RPMB_SZ_MAC];
  char Data[RPMB_SZ_DATA];
  char Nonce[RPMB_SZ_NONCE];               //16bytes
  char WriteCounter[RPMB_SZ_COUNTER];      //4bytes
  char Address[RPMB_SZ_ADDRESS];           //2bytes
  char BlockCount[RPMB_SZ_BLK_COUNT];      //2bytes
  char Result[RPMB_SZ_RESULT];             //2bytes
  char RequestResponse[RPMB_SZ_REQ_RESP];  //2bytes
} RpmbDataFrame;

为了便于跨模块调用，这里重新定义了一个新的结构体，去掉了Stuff和KeyMac字段，如下：

typedef struct {                                //total 288byte = 16 * 18
  char Hmac_Data[RPMB_SZ_DATA];                 //256 bytes
  char Hmac_Nonce[RPMB_SZ_NONCE];               //16  bytes
  char Hmac_WriteCounter[RPMB_SZ_COUNTER];      //4   bytes
  char Hmac_Address[RPMB_SZ_ADDRESS];           //2   bytes
  char Hmac_BlockCount[RPMB_SZ_BLK_COUNT];      //2   bytes
  char Hmac_Result[RPMB_SZ_RESULT];             //2   bytes
  char Hmac_RequestResponse[RPMB_SZ_REQ_RESP];  //2   bytes
  char Hmac_Reserved[RPMB_SZ_RESERVED];         //4   bytes
} HmacRpmbDataFrame;

下面开始构建测试的数据，传输时可能会用到这些字段

	RpmbDataFrame dataFrame;
	memset(&dataFrame, 0, sizeof(RpmbDataFrame));
	
	//init data
	memcpy(dataFrame.Stuff, "aaaabbbbccccddddaaaabbbbccccddddaaaabbbbccccddddaaaabbbbccccddddaaaabbbbccccddddaaaabbbbccccddddaaaabbbbccccddddaaaabbbbccccddddaaaabbbbccccddddaaaabbbbccccddddaaaabbbbccccddddaaaabbbbccccddddaaaa", 196);
	memcpy(dataFrame.KeyMac, "hhiijjkkhhiijjkkhhiijjkkhhiijjkk", 32);
	memcpy(dataFrame.Data, "1111222233334444111122223333444411112222333344441111222233334444111122223333444411112222333344441111222233334444111122223333444411112222333344441111222233334444111122223333444411112222333344441111222233334444111122223333444411112222333344441111222233334444", 256);
	memcpy(dataFrame.WriteCounter, "1234", RPMB_SZ_COUNTER); //4 bytes
	memcpy(dataFrame.Address, "12", RPMB_SZ_COUNTER);        //2 byte
	memcpy(dataFrame.BlockCount, "34", RPMB_SZ_BLK_COUNT);   //2 bytes
	memcpy(dataFrame.RequestResponse, "56", RPMB_SZ_REQ_RESP); //2 bytes

然后我们把这些初始的数据，拷贝到另一个待运算的结构体中

	//copy data to HmacRpmbDataFrame struct
	HmacRpmbDataFrame hmacRpmbData;
	memset(&hmacRpmbData, 0, sizeof(HmacRpmbDataFrame));
	memcpy(hmacRpmbData.Hmac_Data, dataFrame.Data, RPMB_SZ_DATA);
	memcpy(hmacRpmbData.Hmac_Nonce, dataFrame.Nonce, RPMB_SZ_NONCE);
	memcpy(hmacRpmbData.Hmac_WriteCounter, dataFrame.WriteCounter, RPMB_SZ_COUNTER);
	memcpy(hmacRpmbData.Hmac_Address, dataFrame.Address, RPMB_SZ_ADDRESS);
	memcpy(hmacRpmbData.Hmac_BlockCount, dataFrame.BlockCount, RPMB_SZ_BLK_COUNT);
	memcpy(hmacRpmbData.Hmac_Result, dataFrame.Result, RPMB_SZ_RESULT);
	memcpy(hmacRpmbData.Hmac_RequestResponse, dataFrame.RequestResponse, RPMB_SZ_REQ_RESP);

接下来的跨模块传输需求是一次只能发送16个字节，函数有四个参数，每个参数4个字节。

	int *RotInfoPoint = (int *)&hmacRpmbData;
	int *RotInfoPointHeader = (int *)&hmacRpmbData;
	int arg0, arg1, arg2, arg3;

	for (int i = 0; i < 18; i++) //284 bytes ,18*16 = 288
	{
		arg0 = *RotInfoPoint;
		RotInfoPoint++;
		arg1 = *RotInfoPoint;
		RotInfoPoint++;
		arg2 = *RotInfoPoint;
		RotInfoPoint++;
		arg3 = *RotInfoPoint;
		RotInfoPoint++;
		
		printf("[%d] arg0:0x%x, arg1:0x%x, arg2:0x%x, arg3:0x%x\n",
			i+1, arg0,arg1,arg2,arg3);
	}
	
	//reset point to header position
	RotInfoPoint = RotInfoPointHeader;

完整demo Code：

#define RPMB_SZ_STUFF		  196
#define RPMB_SZ_MAC		      32
#define RPMB_SZ_DATA		  256
#define RPMB_SZ_NONCE		  16
#define RPMB_SZ_COUNTER       4
#define RPMB_SZ_ADDRESS       2
#define RPMB_SZ_BLK_COUNT     2
#define RPMB_SZ_RESULT        2
#define RPMB_SZ_REQ_RESP      2
#define RPMB_SZ_RESERVED      4

#define HMAC_DATALEN 
#define HMAC_COUNT(x) (x + 1)

typedef struct {
  char Stuff[RPMB_SZ_STUFF];
  char KeyMac[RPMB_SZ_MAC];
  char Data[RPMB_SZ_DATA];
  char Nonce[RPMB_SZ_NONCE];               //16bytes
  char WriteCounter[RPMB_SZ_COUNTER];      //4bytes
  char Address[RPMB_SZ_ADDRESS];           //2bytes
  char BlockCount[RPMB_SZ_BLK_COUNT];      //2bytes
  char Result[RPMB_SZ_RESULT];             //2bytes
  char RequestResponse[RPMB_SZ_REQ_RESP];  //2bytes
} RpmbDataFrame;

typedef struct {                                //total 288byte = 16 * 18
  char Hmac_Data[RPMB_SZ_DATA];                 //256 bytes
  char Hmac_Nonce[RPMB_SZ_NONCE];               //16  bytes
  char Hmac_WriteCounter[RPMB_SZ_COUNTER];      //4   bytes
  char Hmac_Address[RPMB_SZ_ADDRESS];           //2   bytes
  char Hmac_BlockCount[RPMB_SZ_BLK_COUNT];      //2   bytes
  char Hmac_Result[RPMB_SZ_RESULT];             //2   bytes
  char Hmac_RequestResponse[RPMB_SZ_REQ_RESP];  //2   bytes
  char Hmac_Reserved[RPMB_SZ_RESERVED];         //4   bytes
} HmacRpmbDataFrame;

int main(void) {
	printf("test hmac\n");
	RpmbDataFrame dataFrame;
	memset(&dataFrame, 0, sizeof(RpmbDataFrame));
	
	//init data
	memcpy(dataFrame.Stuff, "aaaabbbbccccddddaaaabbbbccccddddaaaabbbbccccddddaaaabbbbccccddddaaaabbbbccccddddaaaabbbbccccddddaaaabbbbccccddddaaaabbbbccccddddaaaabbbbccccddddaaaabbbbccccddddaaaabbbbccccddddaaaabbbbccccddddaaaa", 196);
	memcpy(dataFrame.KeyMac, "hhiijjkkhhiijjkkhhiijjkkhhiijjkk", 32);
	memcpy(dataFrame.Data, "1111222233334444111122223333444411112222333344441111222233334444111122223333444411112222333344441111222233334444111122223333444411112222333344441111222233334444111122223333444411112222333344441111222233334444111122223333444411112222333344441111222233334444", 256);
	memcpy(dataFrame.WriteCounter, "1234", RPMB_SZ_COUNTER); //4 bytes
	memcpy(dataFrame.Address, "12", RPMB_SZ_COUNTER);        //2 byte
	memcpy(dataFrame.BlockCount, "34", RPMB_SZ_BLK_COUNT);   //2 bytes
	memcpy(dataFrame.RequestResponse, "56", RPMB_SZ_REQ_RESP); //2 bytes


	//copy data to HmacRpmbDataFrame struct
	HmacRpmbDataFrame hmacRpmbData;
	memset(&hmacRpmbData, 0, sizeof(HmacRpmbDataFrame));
	memcpy(hmacRpmbData.Hmac_Data, dataFrame.Data, RPMB_SZ_DATA);
	memcpy(hmacRpmbData.Hmac_Nonce, dataFrame.Nonce, RPMB_SZ_NONCE);
	memcpy(hmacRpmbData.Hmac_WriteCounter, dataFrame.WriteCounter, RPMB_SZ_COUNTER);
	memcpy(hmacRpmbData.Hmac_Address, dataFrame.Address, RPMB_SZ_ADDRESS);
	memcpy(hmacRpmbData.Hmac_BlockCount, dataFrame.BlockCount, RPMB_SZ_BLK_COUNT);
	memcpy(hmacRpmbData.Hmac_Result, dataFrame.Result, RPMB_SZ_RESULT);
	memcpy(hmacRpmbData.Hmac_RequestResponse, dataFrame.RequestResponse, RPMB_SZ_REQ_RESP);


	int *RotInfoPoint = (int *)&hmacRpmbData;
	int *RotInfoPointHeader = (int *)&hmacRpmbData;
	int arg0, arg1, arg2, arg3;

	for (int i = 0; i < 18; i++) //284 bytes ,18*16 = 288
	{
		arg0 = *RotInfoPoint;
		RotInfoPoint++;
		arg1 = *RotInfoPoint;
		RotInfoPoint++;
		arg2 = *RotInfoPoint;
		RotInfoPoint++;
		arg3 = *RotInfoPoint;
		RotInfoPoint++;
		
		printf("[%d] arg0:0x%x, arg1:0x%x, arg2:0x%x, arg3:0x%x\n",
			i+1, arg0,arg1,arg2,arg3);
	}
	
	//reset point to header position
	RotInfoPoint = RotInfoPointHeader;
	printf("test hmac done.\n");
}

运行结果：

$ ./test
test hmac
[1] arg0:0x31313131, arg1:0x32323232, arg2:0x33333333, arg3:0x34343434
[2] arg0:0x31313131, arg1:0x32323232, arg2:0x33333333, arg3:0x34343434
[3] arg0:0x31313131, arg1:0x32323232, arg2:0x33333333, arg3:0x34343434
[4] arg0:0x31313131, arg1:0x32323232, arg2:0x33333333, arg3:0x34343434
[5] arg0:0x31313131, arg1:0x32323232, arg2:0x33333333, arg3:0x34343434
[6] arg0:0x31313131, arg1:0x32323232, arg2:0x33333333, arg3:0x34343434
[7] arg0:0x31313131, arg1:0x32323232, arg2:0x33333333, arg3:0x34343434
[8] arg0:0x31313131, arg1:0x32323232, arg2:0x33333333, arg3:0x34343434
[9] arg0:0x31313131, arg1:0x32323232, arg2:0x33333333, arg3:0x34343434
[10] arg0:0x31313131, arg1:0x32323232, arg2:0x33333333, arg3:0x34343434
[11] arg0:0x31313131, arg1:0x32323232, arg2:0x33333333, arg3:0x34343434
[12] arg0:0x31313131, arg1:0x32323232, arg2:0x33333333, arg3:0x34343434
[13] arg0:0x31313131, arg1:0x32323232, arg2:0x33333333, arg3:0x34343434
[14] arg0:0x31313131, arg1:0x32323232, arg2:0x33333333, arg3:0x34343434
[15] arg0:0x31313131, arg1:0x32323232, arg2:0x33333333, arg3:0x34343434
[16] arg0:0x31313131, arg1:0x32323232, arg2:0x33333333, arg3:0x34343434
[17] arg0:0x0, arg1:0x0, arg2:0x0, arg3:0x0
[18] arg0:0x34333231, arg1:0x34333231, arg2:0x36350000, arg3:0x0
test hmac done.
$
楼中望月
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C语言结构体数组和结构体数组指针对成员的访问
Lontern的博客
09-17 1992
C语言结构体数组和结构体数组指针对成员的访问
【C 语言】数组 ( 指针数组用法 | 菜单选择 )
让 学习 成为一种 习惯 ( 韩曙亮 の 技术博客 )
11-30 1398
一、指针数组用法 ( 菜单选择 )、 二、完整代码示例
C语言字符数组、指针总结
qq_48017759的博客
10-25 3669
C语言字符数组、指针总结
c语言函数指针 demo,C语言基础回顾（长期更新）：指针，线程
weixin_39951396的博客
05-19 144
函数指针##在结构体里面定义函数指针func，然后在main里面给这个指针赋值为add函数#include struct DEMO{int x,y;int (*func)(int,int); //函数指针};int add1(int x,int y){return x*y;}int add2(int x,int y){return x+y;}int main(){struct DEMO demo;...
字符指针修改字符、字符数组修改字符、String类修改字符。总有一款符合你的需求
qq_44850917的博客
12-12 7499
字符指针赋值探究小结 1， 字符指针有初始值时，不能修改其中字符的值 #include<iostream> using namespace std; int main() { char *p1 = "nihao";//字符指针赋值给字符指针只能读不能修改字符的值 char *p2 = p1; p1[0] = 'm';//尝试修改，会报错 return 0; } 会报错： 2...
嵌入式C语言浮点数到字符数组转换.pdf
09-19
"嵌入式C语言浮点数到字符数组转换" 本文档主要介绍了一种在嵌入式C语言环境下，不调用库函数实现浮点数到字符数组的转换方法。该方法可以避免使用库函数而导致程序空间增加的问题。 首先，文档分析了浮点数到字符...
C语言用指针将字符串数组位置颠倒
07-11
C语言用指针将字符串数组位置颠倒，实现ABCDEFGHIJKLMNOPQRSTUVWXYZ转换成ZYXWVUTSRQPONNOPQRSTUVWXYZ
C语言之从字符数组中删除特定的字符
12-31
从字符数组中删除特定的字符，即输入要删除的指定字符，利用for循环找到非指定字符，将非指定字符输出即可。以下为具体的实现方法： #include int main() { char str[100],c; int j,k; printf(please input a ...
C语言中关于字符数组与字符指针
07-21
本文主要讲了C语言中关于字符数组与字符指针的区别与用法，希望对你的学习有所帮助。
c语言利用指针求数组的最大值与最小值
05-16
c语言利用指针求数组的最大值与最小值，下载资源，数组可扩展。
C/C++中字符指针与字符数组对同一数据的修改
m0_51961114的博客
10-18 685
写本博客的起源在于，有一天忽然不清楚，为什么对字符指针指向的数据进行修改，但字符数组却可以。的首地址，所以只对其元素进行读是可以，但如果进行修改则违反了常量区只读的属性，从而会报错！数组空间里的，常量区中的并未修改~！是在常量区，此时的p保存的是常量区中。为数组，有自身空间，所以。是存于常量区，但因为。
在C语言中使用指针读取数组—指针法
127.0.0.1的博客
03-24 5616
在C语言中指针很重要，数组也很重要，那么如他们两碰在了一起会是怎样的呢？让我们拭目以待
字符数组与字符串指针
chengchaonan的博客
03-31 302
字符数组： char a[]="aaaaa"; 存储上：如果是局部变量，那么会在栈中以a作为首地址开辟出6个字符空间即可，自动加上\0这个字符的存储。 字符串： char *a="aaaaa"; 存储上：在常量区分配出包括\0在内的6个字符空间，指针中存储这个地址即可。 所以还要在栈上给这个指针变量开辟出4个字节的存储单元（具体要看平台的大小）， 32位处理器上32位操作系统的32位...
指针与字符串，读取字符串，字符串库函数举例 C语言入门
橘子冰的博客
08-29 1784
欢迎关注笔者，你的支持是持续更博的最大动力 目录类型（字符串 v.s. 字符数组）指针和字符串（scanf举例）库函数举例相关内容其他 本文主要讨论： 字符串、字符数组名称的类型 读取整数、字符数组的区别 操作字符串的库函数举例 类型（字符串 v.s. 字符数组） 字符串常量类型：char * 字符数组名称的类型也是 char * 举例 char * word = "Please input your name:"; //"Please input your name:"是字符串常量，类型:.
(C语言）指针进阶(1)——字符指针、数组指针
LYJbao的博客
07-06 2515
一、字符指针二、数组指针 回顾关于数组名的理解
（转载备忘）字符指针与字符数组
欢迎来到爱吃橘子的程序媛的代码妙妙屋！
01-23 1537
转载自：字符数组与字符指针 - 不弃初衷 - 博客园 (cnblogs.com) 1.字符指针可以指向一个字符串。 　　我们可以用字符串常量对字符指针进行初始化。例如，有说明语句： char *str = "This is a string."; 　　是对字符指针进行初始化。此时，字符指针指向的是一个字符串常量的首地址，即指向字符串的首地址。 　　这里要注意字符指针与字符数组之间的区别。例如，有说明语句： char string[ ]="This is a string."; 　　此时，s
c语言中字符指针数组,C语言中的字符数组与字符指针
weixin_32467421的博客
05-17 1186
1.字符指针可以指向一个字符串。我们可以用字符串常量对字符指针进行初始化。例如，有说明语句：char*str = "This is a string.";是对字符指针进行初始化。此时，字符指针指向的是一个字符串常量的首地址，即指向字符串的首地址。这里要注意字符指针与字符数组之间的区别。例如，有说明语句：charstring[ ]="This is a string.";此时，string是字符数组...
【C语言】字符串、字符数组、字符指针
Jacky_Feng的博客
10-12 4467
目录 一、字符数组 （1）字符数组的定义 （2）字符数组的初始化 二、字符串 （1）字符串的概念 （2）用字符串初始化字符字符数组 （3）获取字符串的长度 三、字符串与指针 四、字符数组与字符指针 一、字符数组 字符数组是存放字符数据的数组，每个元素都是单个字符。 （1）字符数组的定义 char 数组名[数组长度]；//一维字符数组 char 数组名[常量表达式1][常量表达式2];//二维字符数组 （2）字符数组的初始化 在数组定义的同时对数组中的元素进行赋值，这个过程
C语言指针数组与数组指针
最新发布
09-22
C语言中，指针数组和数组指针是两种不同的概念。 指针数组是指一个数组中的每个元素都是一个指针。这意味着每个元素存储的是一个内存地址，可以指向其他变量或数据。指针数组的声明形式为：`类型 *数组名[数组大小]...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值