我正在尝试找到一个更好的标题，所以如果它令人困惑，我深表歉意。
我有一条二进制消息，我正在通过串行端口读取。消息包含一个常量的 8 字节标头和一个动态消息长度(取决于 8 字节标头中定义的消息类型(。
我正在尝试创建一个函数，该函数使用malloc分配的数组返回此消息。
我更改了一些变量/成员名称只是为了使其更清晰 例：
#include <stdlib.h>
#include <stdio.h>
typedef struct MyMessageHeader {
uint8_t byte1, byte2, byte3, byte4, byte5, byte6, byte7,
} MyMessageHeader;
// I could have up to 100 different message types, but they all contain
// the same header, so trying to make a message type with a header and array pointer
typedef struct MyMessage {
MyMessageHeader header;
uint8_t* data;
} MyMessage;
// Function to copy a raw byte array that is read from the serial port into
// a MyMessage object
MyMessage* FunctionThatIsNotWorking(uint8_t* rawBytes) {
// Somehow we have determined in rawBytes that this message contains 12 bytes of data
// plus the 8 bytes which is the header
MyMessage* ret_msg = malloc(20);
// This is where things go wrong and I get segmentation faults. Likely due to
// my misunderstanding of malloc.
// Copy the rawBytes into MyMessage. Assuming the first 8 bytes of rawBytes goes
// into MyMessageHeader, and the last 12 bytes go into data
memcpy(ret_msg, rawBytes, 20);
}
int main() {
uint8_t raw_bytes[20] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20};
MyMessage* my_msg = FunctionThatIsNotWorking(raw_bytes);
// Expecting now but this doesnt work
my_msg->header.byte1 == 1;
my_msg->header.byte2 == 2;
my_msg->header.byte3 == 3;
// ...
// first byte of data should be the 9th byte in raw_bytes
my_msg->data[0] == 9;
my_msg->data[1] == 10;
}
我在这里错过了什么，或者我的误解是什么？
我怀疑你的字节(双关语(是结构填充
建议：
-
将数据直接从设备读取到本地缓冲区中。 使缓冲区至少与最大的预期消息一样长。
-
读取标题
-
执行你的"malloc"，最后
-
将数据从缓冲区解压缩到您中
OK：这是我的建议：
/*
* SAMPLE OUTPUT:
* sizeof(*my_msg)= 16
* header: 01 02 03 04 05 06 07 08
* data: 09 0a 0b 0c 0d 0e 0f 10 11 12 13 14
*/
#include <stdio.h>
#include <stdint.h> // unit8_t
#include <stdlib.h> // malloc()
#include <string.h> // memcpy ()
typedef struct MyMessage {
uint8_t header[8]; // 8 bytes (you said) for header; message length unknown.
uint8_t* data; // Here, you're only allocating space for a pointer (e.g. 4 bytes)
} MyMessage_t;
MyMessage_t* FunctionThatIsNotWorking(uint8_t* rawBytes) {
// Let's assume rawBytes contains header + data
// Parse the header, determine message type, and determine message length
// ... TBD ...
// Allocate your struct
MyMessage_t* ret_msg = malloc(sizeof (struct MyMessage));
// Now allocate space for your *data* (let's assume this particular message has 12 bytes)
ret_msg->data = malloc(12);
// Copy your header (from rawBytes)
memcpy(&ret_msg->header, rawBytes, 8);
// Copy the data (starting on the ninth byte; assume the data is contiguous)
memcpy(ret_msg->data, &rawBytes[8], 12);
// Return the completed record
return ret_msg;
}
int main() {
int i;
// Create some dummy data
uint8_t raw_bytes[20] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20};
MyMessage_t* my_msg = FunctionThatIsNotWorking(raw_bytes);
printf ("sizeof(*my_msg)= %ldn", sizeof(*my_msg));
printf ("header: ");
for (i=0; i<sizeof(my_msg->header); i++) {
printf("%02x ", my_msg->header[i]);
}
printf ("ndata: ");
for (i=0; i<12; i++) {
printf("%02x ", my_msg->data[i]);
}
printf ("n");
return 0;
}
我想说的是，编译器给你的结构的字节布局不一定是你所期望的。字段中通常有"额外的间距"，以确保对齐。
如果在发送端使用结构(在构造消息时(，则接收方中的数据布局不一定与发送方中的布局匹配。
因此，您通常需要显式"打包"和"解压缩"在不同主机/不同平台之间来回发送的消息。
我认为重点是强调你从来没有为你的数据分配空间。 这是真的:) 我希望上面的例子有所帮助。
最后，在大多数情况下，在您实际读取标头之前，消息的长度是未知的。 我的示例也处理这种情况。
如果您只想将数据传递回调用方(我的示例复制标头和数据(，您可能需要在结构中添加"消息长度"字段。
始终尝试使用"sizeof"运算符，而不是硬编码"幻数"。 下一个最好的办法是声明常量(例如#define DATA_LENGTH 12(。
"希望对您有所帮助！
再举一个例子。
假设您知道您的消息数据将始终正好是 12 个字节。 让我们仍然假设您希望标头字段为 8 个字节。 您可以这样做：
...
typedef struct MyMessage {
uint8_t header[8]; // 8 bytes (you said) for header
uint8_t data[12]; // This allocates 12 bytes
} MyMessage_t;
...
MyMessage_t* FunctionThatIsNotWorking(uint8_t* rawBytes) {
// Let's assume rawBytes contains header + data
// Parse the header, determine message type, and determine message length
// ... TBD ...
// Allocate your struct
MyMessage_t* ret_msg = malloc(sizeof (*ret_msg));
// Copy directly from rawBytes
memcpy(ret_msg, rawBytes, sizeof (*ret_msg));
// Return the completed record
return ret_msg;
}