C 如何用不同的方法修复结构黑客分配的内存？

我正在用C语言开发一个用于通信的驱动程序，交换的消息没有固定的大小。通信总线的建议是对多主题使用结构，这也是我的情况

我的第一个问题是：我必须不断地监听新消息，当我收到一条消息时，我必须处理消息数据（它有一个延迟），并且仍然在监听新消息

第一种解决方案：在收到新消息时使用线程来处理数据

我的第二个问题：消息中的数据可以有一个结构的多个数据，而我的通信器需要使用一个结构来组织这多个值

第二种解决方案：使用struct hack来分配struct的内存动态大小

我目前的问题是：当我将struct作为参数传递给线程或任何函数时，我失去了数据结构并得到了错误的值

进行的短测试是：

typedef struct test{
    int size;
    int value[];
} test;

void allocation(test *v){
    test *aux = (test *)malloc(sizeof(test)+3*sizeof(int));
    int i;
    aux->value[0] = 2;
    aux->size = 3;
    aux->value[1] = 1;
    aux->value[2] = 5;
    printf("Teste1 %d\n",aux->size);
    for(i=0; i < aux->size; i++){
        printf("%d\n", aux->value[i]);
    }
    *v = *aux;
}

void cleanup(test *v){
    free(v);
}

int main(int argc, char *argv[]){
    test v;
    int i;

    allocation(&v);
    printf("Teste2 %d\n",v.size);
    for(i=0; i < v.size; i++){
        printf("%d\n", v.value[i]);
    }
    //cleanup(&v);
    return 0;
}

---

一旦我有了所有需要修复的元素，你知道如何修复该函数中的内存结构吗？请记住，我也可以分配多个

test2

数据是可取的（不是必需的）。

您将

v

声明为非指针，这意味着当您在

main

中声明它时，内存已经分配给

v

。将引用发送到

分配

只会正确复制

大小

，因为它不是动态分配的。正确的方法是：

• 将您的

  v

  声明为指针

• 让您的

  分配

  返回

  test*

  （

  test*分配（）

  ）

• 将其分配到

  main

  中的

  v

  。i、 例如

  v=allocate（）

• 然后像指针一样使用

  v

编辑：因为OP希望它只作为参数工作，所以最好的方法是使用双指针。检查以下代码：

typedef struct test{
    int size;
    int value[];
} test;

void allocation(test **v){
    test *aux = (test *)malloc(sizeof(test)+3*sizeof(int));
    int i;
    aux->value[0] = 2;
    aux->size = 3;
    aux->value[1] = 1;
    aux->value[2] = 5;
    printf("Teste1 %d\n",aux->size);
    for(i=0; i < aux->size; i++){
        printf("%d\n", aux->value[i]);
    }
    *v = aux;
}

void cleanup(test *v){
    free(v);
}

int main(int argc, char *argv[]){
    test **v;
    v = malloc (sizeof (test*));
    int i;

    allocation(v);
    printf("Teste2 %d\n",(*v)->size);
    for(i=0; i < (*v)->size; i++){
        printf("%d\n", (*v)->value[i]);
    }
    //cleanup(&v);
    return 0;
}

typedef结构测试{
整数大小；
int值[]；
}试验；
无效分配（测试**v）{
test*aux=（test*）malloc（sizeof（test）+3*sizeof（int））；
int i；
辅助->值[0]=2；
辅助->大小=3；
辅助->值[1]=1；
辅助->值[2]=5；
printf（“Teste1%d\n”，辅助->大小）；
对于（i=0；isize；i++）{
printf（“%d\n”，辅助->值[i]）；
}
*v=辅助；
}
空洞清理（测试*v）{
免费（五）；
}
int main（int argc，char*argv[]）{
试验**v；
v=malloc（sizeof（test*））；
int i；
分配（五）；
printf（“Teste2%d\n”，（*v）->大小）；
对于（i=0；i<（*v）->大小；i++）{
printf（“%d\n”，（*v）->值[i]）；
}
//清理（&v）；
返回0；
}

---

请注意，在此之后清理也将更改。

您将

v

声明为非指针，这意味着当您在

main

中声明时，内存已分配给

v

。将引用发送到

分配

只会正确复制

大小

，因为它不是动态分配的。正确的方法是：

• 将您的

  v

  声明为指针

• 让您的

  分配

  返回

  test*

  （

  test*分配（）

  ）

• 将其分配到

  main

  中的

  v

  。i、 例如

  v=allocate（）

• 然后像指针一样使用

  v

编辑：因为OP希望它只作为参数工作，所以最好的方法是使用双指针。检查以下代码：

typedef struct test{
    int size;
    int value[];
} test;

void allocation(test **v){
    test *aux = (test *)malloc(sizeof(test)+3*sizeof(int));
    int i;
    aux->value[0] = 2;
    aux->size = 3;
    aux->value[1] = 1;
    aux->value[2] = 5;
    printf("Teste1 %d\n",aux->size);
    for(i=0; i < aux->size; i++){
        printf("%d\n", aux->value[i]);
    }
    *v = aux;
}

void cleanup(test *v){
    free(v);
}

int main(int argc, char *argv[]){
    test **v;
    v = malloc (sizeof (test*));
    int i;

    allocation(v);
    printf("Teste2 %d\n",(*v)->size);
    for(i=0; i < (*v)->size; i++){
        printf("%d\n", (*v)->value[i]);
    }
    //cleanup(&v);
    return 0;
}

typedef结构测试{
整数大小；
int值[]；
}试验；
无效分配（测试**v）{
test*aux=（test*）malloc（sizeof（test）+3*sizeof（int））；
int i；
辅助->值[0]=2；
辅助->大小=3；
辅助->值[1]=1；
辅助->值[2]=5；
printf（“Teste1%d\n”，辅助->大小）；
对于（i=0；isize；i++）{
printf（“%d\n”，辅助->值[i]）；
}
*v=辅助；
}
空洞清理（测试*v）{
免费（五）；
}
int main（int argc，char*argv[]）{
试验**v；
v=malloc（sizeof（test*））；
int i；
分配（五）；
printf（“Teste2%d\n”，（*v）->大小）；
对于（i=0；i<（*v）->大小；i++）{
printf（“%d\n”，（*v）->值[i]）；
}
//清理（&v）；
返回0；
}

---

请注意，在此之后，您的清理也将更改。

这里的问题是，您分配的结构具有不完整的成员

int-value[]

；虽然原则上可以按值复制两个结构（如果您编写

*v=*aux

，实际上就是这样）；但是，由于编译器不知道运行时将采用哪个大小的成员

值[]

，因此

v

的“sizeof”以及

*aux

的大小始终为4，即一个int成员的已知大小

size

。因此，仅复制该数组，而不会复制

值[]

-array

解决这种情况的方法是需要一个指向指针的指针（即

分配（test**v）

），这样就可以使用main中指向struct test的指针（即

test*vptr

）将保留的内存直接分配给它，并调用

分配（&vptr）

---

如果您无法避免传递对值的尊重（而不是对值指针的引用），我认为您必须使用

memcpy

来传输内容。但这实际上没有意义，因为这样一来，接收方必须提供足够的空间来提前接收

value[]

-数组（如果您简单地声明一个形式为

test v

的变量，情况就不是这样了。）那么

malloc

和

aux

将毫无意义；您可以直接写入通过引用传递的对象

v

。

这里的问题是，您分配的结构具有不完整的成员

int值[]

；虽然原则上可以按值复制两个结构（如果编写

*v=*aux

），但是