C - 在没有 malloc 的函数内填充通用结构

Question

我正在尝试构建一个可以填充结构的通用函数无需任何动态内存分配。

以下代码是我正在尝试做的一个简单示例。 此代码不会编译为incomplete type 'void' is not assignable。

请注意，这是一个突出我的问题的玩具示例。我真的不想转换颜色；我只是想强调一下，这些结构的数据类型和大小会有所不同。

#include <stdio.h>

typedef struct {
    int r;
    int g;
    int b;
} rgb_t;

typedef struct {
    float c;
    float m;
    float y;
    float k;
} cmyk_t;

typedef enum { RGB, CMYK } color_t;

void convert_hex_to_color(long hex, color_t colorType, void* const out) {
    if (colorType == RGB) {
        rgb_t temp = { 0 };
        // Insert some conversion math here....
        temp.r = 1;
        temp.g = 2;
        temp.b = 3;
        *out = temp; //< [!]
    } else
    if (colorType == CMYK) {
        cmyk_t temp = { 0 };
        // Insert some conversion math here....
        temp.c = 1.0;
        temp.m = 2.0;
        temp.y = 3.0;
        temp.k = 4.0;
        *out = temp; //< [!]
    }
}

int main(void) {
    // Given
    long hex = 348576;
    rgb_t mydata = { 0 };
    convert_hex_to_color(hex, RGB, (void*)(&mydata));

    // Then
    printf("RGB = %i,%i,%i\r\n", mydata.r, mydata.g, mydata.b);
    return 0;
}

对于一些额外的上下文，我在嵌入式系统目标上使用 C11。

最好的[1] 方法是什么？宏？联合？

问候，
加布里埃尔

[1] 我将“最佳”定义为可读性和安全性之间的良好折衷。

Answer 1

错误的原因是通过void指针存储无效：编译器不知道要存储什么。您可以将指针转换为 *(rgb_t *)out = temp; 或 *(cmyk_t *)out = temp;

或者，您可以将temp 定义为指向适当结构类型的指针，并直接从out 对其进行初始化，而无需进行C 中不需要的强制转换：

void convert_hex_to_color(long hex, color_t colorType, void *out) {
    if (colorType == RGB) {
        rgb_t *temp = out;
        // Insert some conversion math here....
        temp->r = 1;
        temp->g = 2;
        temp->b = 3;
    } else
    if (colorType == CMYK) {
        cmyk_t *temp = out;
        // Insert some conversion math here....
        temp->c = 1.0;
        temp->m = 2.0;
        temp->y = 3.0;
        temp->k = 4.0;
    }
}

请注意，C 中不需要强制转换：

int main(void) {
    // Given
    long hex = 348576;
    rgb_t mydata = { 0 };
    convert_hex_to_color(hex, RGB, &mydata);

    // Then
    printf("RGB = %i,%i,%i\r\n", mydata.r, mydata.g, mydata.b);
    return 0;
}

Answer 2

rgb_t temp = {0};

这样就在rgb_t 类型的堆栈上声明了一个变量。到目前为止一切顺利，虽然你不需要那个 0。

*out = temp;

这是您的问题：在 C 中您只能复制相同类型的内存。曾经。这与malloc 无关，正如您的标题所示，这只是基本的语言规范。当然，有些类型提供隐式转换，但 void* 不是其中之一。

因此，如果您要复制一个结构（右侧的rgb_t），则目标必须是同一类型。所以把这一行改成这样：

*(rgb_t *)out = temp;

Answer 3

“最好”的方法是不要在同一个函数中混合不相关的结构，或者在同一个内存区域中。这只是乱七八糟的设计。

如果您需要为两种不同形式的数据保持一致的 API，那么一个类似类型安全函数的宏可能是一个想法。您可以伪造这样的宏，使其具有类似于通过指针传递数据的语法

void convert_hex_to_color(long hex, type* data)

然后使用 C11 _Generic 来实际确定要使用的正确类型，而不是使用危险的 void 指针。由于您不能“通过引用”将参数传递给宏，因此您必须在其中潜入变量赋值。示例：

#include <stdio.h>

typedef struct {
    int r;
    int g;
    int b;
} rgb_t;

typedef struct {
    float c;
    float m;
    float y;
    float k;
} cmyk_t;



void convert_hex_to_color(long hex, void* data);
  /* 
     Pretty prototype just for code documentation purposes. 
     Never actually defined or called - the actual macro will "mock" this function. 
  */

#define convert_hex_to_color(hex, output) ( *(output) = _Generic(*(output), \
  rgb_t:  (rgb_t){ .r=1, .g=2, .b=3 }, \
  cmyk_t: (cmyk_t){ .c=1.0, .m=2.0, .y=3.0, .k=4.0 } ) )


int main(void) {
    // Given
    long hex = 348576;
    rgb_t  myrgb  = { 0 };
    cmyk_t mycmyk = { 0 };

    convert_hex_to_color(hex, &myrgb);
    convert_hex_to_color(hex, &mycmyk);

    printf("RGB  = %i,%i,%i\r\n", myrgb.r, myrgb.g, myrgb.b);
    printf("CMYK = %f,%f,%f,%f\r\n", mycmyk.c, mycmyk.m, mycmyk.y, mycmyk.k);
    return 0;
}

输出：

RGB  = 1,2,3
CMYK = 1.000000,2.000000,3.000000,4.000000

---

请注意 _Generic 对类型限定符（const 等）的支持在 C11 中是不稳定的 - 一些 C11 编译器处理 const rgb_t 与 rgb_t 不同，其他编译器处理它们相同。这是 C17 中的“错误修复”之一，因此请使用 C17（如果可用）。

Answer 4

帧挑战：您似乎想要根据传递给此函数的类型执行不同的操作。而不是使用枚举来告诉它你传入的是什么类型，并基于该枚举进行分支，而是使用 C11 的 _Generic 来处理它，你甚至不需要明确地告诉它类型是什么每次调用：

#include <stdio.h>

typedef struct {
    int r;
    int g;
    int b;
} rgb_t;

typedef struct {
    float c;
    float m;
    float y;
    float k;
} cmyk_t;

inline void convert_hex_to_color_rgb(long hex, rgb_t *const out) {
    (void) hex; // or whatever you're planning to do with 'hex'
    out->r = 1;
    out->g = 2;
    out->b = 3;
}

inline void convert_hex_to_color_cmyk(long hex, cmyk_t *const out) {
    (void) hex; // or whatever you're planning to do with 'hex'
    out->c = 1.0;
    out->m = 2.0;
    out->y = 3.0;
    out->k = 4.0;
}

#define convert_hex_to_color(hex, out) _Generic((out), \
        rgb_t *: convert_hex_to_color_rgb((hex), (rgb_t *)(out)), \
        cmyk_t *: convert_hex_to_color_cmyk((hex), (cmyk_t *)(out)) \
)

int main(void) {
    // Given
    long hex = 348576;
    rgb_t mydata = { 0 };
    cmyk_t mydatac = { 0 };
    convert_hex_to_color(hex, &mydata);
    convert_hex_to_color(hex, &mydatac);

    // Then
    printf("RGB = %i,%i,%i\r\n", mydata.r, mydata.g, mydata.b);
    printf("CMYK = %f,%f,%f,%f\r\n", mydatac.c, mydatac.m, mydatac.y, mydatac.k);
    return 0;
}