memcpy 布尔值无效 *

Question

我只是在创建一个测试函数，我必须在 void * 中传递布尔值，以便我可以在其他函数中解析它并使用它。

但我被卡住了，不知道我应该如何在 void * 中存储布尔值。

但是当我在另一个函数中解析它时，我总是得到真值。

#include <stdio.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>

typedef struct {
    int a;
    uint8_t var_data[];
} s;

void parse(s * dummy)
{
    void *var_data = dummy->var_data;
    
    uint8_t *len;
    char type[128];
    bool *leaf;
    for(int i = 0; i < dummy->a; i++)
    {
        len = (uint8_t *)var_data;
        var_data += 1;
        memcpy(type, var_data, *len);
        type[*len] = '\0';
        var_data += *len;
        leaf = (bool *)var_data;
        var_data += 1;
        
        printf("%s\n", type);
        printf("leaf: %s\n\n", leaf ? "true" : "false");
    }
}

int main() 
{
    // Write C code here
    char val[] = "dummy value";
    uint8_t len = strlen(val);
    bool v = false;
    int b = 2;
    int sz = sizeof(s) + b * (sizeof(bool) + len + 1);
    s * dummy = (s *) malloc(sz);
    dummy->a = b;
    void *var = dummy->var_data;
    for(int i = 0; i < dummy->a; i++){
        memcpy(var, &len, 1);
        var += 1;
        memcpy(var, val, len);
        var += len;
        memcpy(var, &v, sizeof(bool));
        var += sizeof(bool);
    }
    parse(dummy);
    return 0;
}

body 可以帮我解决这个问题吗？

Answer 1

var_data 未初始化。你应该用malloc分配var_data，并将leaf中的数据复制进去：

void *var_data = malloc(sizeof(bool));
bool leaf = false;
memcpy(var_data, &leaf, sizeof(bool));

您可以像这样将其转换为bool *：

bool *leaf;
leaf = (bool *) var_data;

此外，您增加var_data 指针。所以var_data 现在指向不同的内存位置。

Answer 2

您没有在此行中取消引用 leaf：

printf("leaf: %s\n\n", leaf ? "true" : "false");

由于leaf 是一个非零指针，它在C 中的计算结果始终为true。您想打印*leaf：

printf("leaf: %s\n\n", *leaf ? "true" : "false");

其他一些杂记：

1. void* 算术（即var_data += 1）在 C 中是非法的，尽管 gcc 不会抱怨。使用char*，因为这是应该用于序列化的类型。

2. 正如其他答案中所提到的，像您现在这样使用指针可能会导致细微的错误。如果您的指针指向一个地址并且您想取消引用它（读取存储在那里的值），最好尽快执行此操作，而不是冒着同时该位置被其他代码更改的风险。

   所以，只需将 char* 数组中的数据复制到目标结构（或 uint8_t 之类的原语）中，然后将指针前进。

3. 技术上允许您在 C 中转换指针的唯一方法是将它们从特定指针（如something*）转换为char*，以便检查它们的内容。您也可以隐式地从void* 转换为void*，但前提是您没有为指针设置别名（试图修改基础类型）。其他方向的任何强制转换都违反了严格的别名，因此您应该尝试改用memcpy。它可能看起来更丑陋，但编译器无论如何都会对其进行优化（see for yourself），并且您将安全（r）从the horrors of aliasing。

4. 让它尽可能地尝试使用 const 正确性是一个好习惯，它有助于编译器在你做错了什么时警告你。如果您的函数正在解析数组，则参数应为const char*。

5. 最后，如果您的目标是序列化和反序列化结构，也许您应该研究protocol buffers 或一些类似的序列化框架。它快速、高效、便携，而且最重要的是，它已经编写好了。

所以，类似：

typedef struct {
    int len;  
    char * var_data;
} example;

// note the const keyword - this means this function is
// not going to change the struct, only read it
void parse(const example * dummy)
{
    // again, pointer to const char
    const char * var_data = dummy->var_data;
    
    // move all variables to the innermost scope
    for (int i = 0; i < dummy->len; i++)
    {
        uint8_t len = 0;
        memcpy(&len, var_data, sizeof(len));
        var_data++;

        ...
    }
}