我创建了三个缓冲区和变量,并将每个变量复制到相应的缓冲区.
然后我从缓冲区中取出指针并将其打印出来.
#include <stdlib.h>
#include <string.h>
int main() {
// Buffers.
unsigned char a_buffer[sizeof(int)];
unsigned char b_buffer[sizeof(int)];
unsigned char c_buffer[sizeof(float)];
// Variables ressources.
int a = 65500;
int b = 32000;
float c = 3.14;
// Variables pointers.
int *aa = NULL;
int *bb = NULL;
float *cc = NULL;
/* Copy variables to buffer. */
memcpy(a_buffer, &a, sizeof(int));
memcpy(b_buffer, &b, sizeof(int));
memcpy(c_buffer, &c, sizeof(float));
/* Set pointers. */
aa = (int*) a_buffer;
bb = (int*) b_buffer;
cc = (float*) c_buffer;
// Print values.
printf("%i %i %f\n", *aa, *bb, *cc);
return 0;
}
产量:65500 32000 3.140000
现在我想将这些变量存储到一个缓冲区中并写下来.
#include <stdlib.h>
#include <stdint.h>
#include <string.h>
int main() {
// Buffer.
unsigned char buffer[sizeof(int) + sizeof(int) + sizeof(float)];
// Buffer pointer (first object).
unsigned char *buf_ptr = buffer;
// Variables ressources.
int a = 65500;
int b = 32000;
float c = 3.14;
// Variables pointers.
int *aa = NULL;
int *bb = NULL;
float *cc = NULL;
/* Copy variables to buffer. */
uint16_t cur = 0;
memcpy(buf_ptr + cur, &a, sizeof(int));
cur += sizeof(int);
memcpy(buf_ptr + cur, &b, sizeof(int));
cur += sizeof(int);
memcpy(buf_ptr + cur, &c, sizeof(float));
cur += sizeof(float);
/* Set pointers. */
cur = 0;
aa = (int*) buf_ptr + cur;
cur += sizeof(int);
bb = (int*) buf_ptr + cur;
cur += sizeof(int);
cc = (float*) buf_ptr + cur;
cur += sizeof(float);
// Print values.
printf("%i %i %f\n", *aa, *bb, *cc);
return 0;
}
产量:65500 2054246226 0.000000
第一个变量是正确的,第二个变量总是变化,第三个变量总是零.
这样做的正确方法是什么?
最佳答案 简短的回答是,在执行aa =(int *)buf_ptr cur部分时,由于指针类型的原因,您似乎正在添加错误的偏移量.
改为使用aa =(int *)(buf_ptr cur)(相应地用于其他指针赋值).
这是一个做到这一点的想法,看起来像是有效的:https://ideone.com/64awsM
原因是:当你将buf_ptr强制转换为(int *)时,你会说这是一个指向整数的指针(这就是你想要的).
但是你给那个指针添加一个偏移量cur,所以如果你把buf_ptr想象成一个数组,那你就是访问buf_ptr [cur],其中每个元素都是一个int.由于你有cur = sizeof(int)(可能是4或8),你很快就会离开缓冲区的范围.如果将buf_ptr保留为char数组,则偏移量是您预期的单个字节,并且您只在最后执行转换.
这也解释了为什么你的第一个元素总是正确的(因为你基本上都在做buf_ptr [0],因为偏移为零,所以元素大小是什么并不重要).