c - 结构体指针作为返回类型

Question

我想打印 kk[i].data[j] 但它根本不打印。

intarr_save_binary 返回 2。我希望得到 0。

int k = sizeof(kk)/sizeof(kk[0]); 给出 0。我期望得到 5。

我是否正确分配了内存？

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

typedef struct {

    int len;
    int *data;

}intarr_t;

#define MAX 5

intarr_t* intarr_create(unsigned int len) {

    intarr_t* new_intarr = (intarr_t*)malloc(sizeof(intarr_t));
    if (!new_intarr) return NULL;

    new_intarr->data = (int*)malloc(len * sizeof(int));
    new_intarr->len = len;
    return new_intarr;

}
int intarr_save_binary(intarr_t* ia, const char* filename) {

    if (!ia) return 1;
    if (!ia->data) return 2;

    FILE* f = fopen(filename, "w");
    if (!f) return 3;

    if (fwrite(&ia->len, sizeof(ia->len), 1, f) == 1) {
        fprintf(f, "%d ", ia->len);
    }
    else {
        return 4;
    }

    if (fwrite(ia->data, sizeof(ia->data), ia->len, f) == ia->len) {
        fclose(f);
        return 0;
    }
    else {
        fclose(f);
        return 5;
    }
}
int main() {

    intarr_t *ia = (intarr_t*)malloc(MAX*sizeof(intarr_t));

    int i;
    int j;
    for (j = 0; j < MAX; j++) {

        ia[j].len = j + 1;

    }

    for (j = 0; j < MAX; j++) {

        ia[j].data = (int*)malloc(ia[j].len * sizeof(int));

    }

    for (j = 0; j < MAX; j++) {
        for (i = 0; i < ia[j].len; i++) {

            ia[j].data = (i + 1) * j;

        }
    }

    char name[20] = "myfile.txt";
    int d;

    printf("%d \n", intarr_save_binary(ia, name));


    intarr_t *kk;
    kk = intarr_create(MAX);


    int k = sizeof(kk) / sizeof(kk[0]);
    printf("%d\n",k);

    for (j = 0; j < k; j++) {
        for (i = 0; i < kk[j].len; i++) {

            printf("%d: %d\n", i, kk[j].data[i]);

        }
        printf("\n");
    }
    free(kk);
    return 0;
}

Answer 1

intarr_save_binary is returning 2. I expect to get 0.

for (j = 0; j < MAX; j++) {
    for (i = 0; i < ia[j].len; i++) {

        ia[j].data = (i + 1) * j;

    }
}

这会在第一次通过双循环时将 ia[0].data 归零。 (ia[0].data = (0 + 1) * 0 给出 0)。

因此 ia->data 为 0，并且 !ia->data 为 true，使得函数返回 2.

<小时/>

int k = sizeof(kk) / sizeof(kk[0]); gives 0. I'm expecting to get 5.

您显然希望 sizeof kk 给出为 kk 分配的内存总量。

实际上，这就是您得到的——为 intarr_t * 分配的内存总量，它是当时 kk 的类型。最有可能的结果是 4 或 8，具体取决于您的架构。它不是调用intarr_create()时len * sizeof(int)产生的结果。正如 @BoPersson 评论的那样，如果您自己分配内存，您必须记住自己分配了多少内存。

sizeof kk/sizeof kk[0]“技巧”仅在 kk 实际上是一个数组时才有效，即如果它已在您使用 sizeof 运算符的范围内进行声明，以便编译器可以“查看”其大小。

因此，当您的结构 kk[0] 中有一个 int 和一个 int * 时，它们一起很可能需要比 intarr_t * 更多的内存，整数除法结果为 0。

<小时/>

您可能还注意到 free() 不是递归的。使用free(kk)，您将泄漏为所有data 成员分配的所有内存。对于每个 malloc()，都需要有一个对应的 free()。 (即使程序在 free() 之后立即结束，确实也很重要，因为并非所有操作系统都可以/将保护您免受此错误的影响。)