C 结构指针作为返回类型_C_Pointers_Struct

C 结构指针作为返回类型

c pointers struct

C 结构指针作为返回类型,c,pointers,struct,C,Pointers,Struct,我想打印kk[I].data[j]，但根本不打印 intarr\u save\u 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; #d

我想打印

kk[I].data[j]

，但根本不打印

intarr\u save\u 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;
}

#包括
#包括
#包括
类型定义结构{
内伦；
int*数据；
}内部审计；
#定义最大值5
intarr\u t*intarr\u创建（无符号整数长度）{
intarr_t*新intarr=（intarr_t*）malloc（sizeof（intarr_t））；
如果（！new_intar）返回NULL；
new_intar->data=（int*）malloc（len*sizeof（int））；
新建\u intar->len=len；
返回新的文件；
}
int intarr\u save\u二进制文件（intarr\u t*ia，const char*filename）{
如果（！ia）返回1；
如果（！ia->data）返回2；
文件*f=fopen（文件名，“w”）；
如果（！f）返回3；
如果（fwrite（&ia->len，sizeof（ia->len），1，f）==1）{
fprintf（f，“%d”，ia->len）；
}
否则{
返回4；
}
如果（fwrite（ia->data，sizeof（ia->data），ia->len，f）=ia->len）{
fclose（f）；
返回0；
}
否则{
fclose（f）；
返回5；
}
}
int main（）{
intarr_t*ia=（intarr_t*）malloc（最大尺寸（intarr_t））；
int i；
int j；
对于（j=0；j

intarr\u save\u二进制文件返回2。我希望得到0
（j=0；j{
对于（i=0；i


这将在第一次通过双循环时将ia[0]数据归零。（ia[0]。数据=（0+1）*0
给出0
）
因此ia->data
是0
，并且！ia->data
为true，使函数返回2


int k=sizeof（kk）/sizeof（kk[0]）；给0。我希望得到5分
显然，您希望sizeof kk
给出为kk
分配的内存总量
这就是你得到的，实际上-，分配给intarr\u t*
的内存总量，这是当时的kk
类型。这很可能导致4或8，这取决于您的体系结构。它不是什么是调用intarr\u create（）
时产生的len*sizeof（int）
结果。正如@BoPersson所评论的，如果你自己分配内存，你必须记住你分配了多少
sizeof kk/sizeof kk[0]
只有当kk
实际上是一个数组时，“技巧”才有效，也就是说，如果它在您使用sizeof
操作符的范围内被声明为数组，那么编译器可以“查看”它的大小
因此，由于结构kk[0]
中有一个int
和一个int*
，它们加在一起很可能需要比intarr\t*
更多的内存，整数除法的结果是0


您可能还注意到free（）
不是递归的。使用free（kk）
，您正在泄漏为所有数据
成员分配的所有内存。对于每个malloc（）
，都需要相应的free（）
。（即使程序正好在那一个free（）
之后结束，它也会起作用，因为不是所有的操作系统都能/将保护您免受此错误的影响。）
kk是指针，而不是数组，因此sizeof kk是1个指针的大小：4或8字节。sizeof（kk）/sizeof（kk[0]）仅适用于数组，不适用于指针。而且也没有办法找出所指内容的总大小。你必须记住你分配了多少。这个ia[j]。数据=（i+1）*j不可能编译，因为数据是指针，并且分配的值是整数。
for (j = 0; j < MAX; j++) {
    for (i = 0; i < ia[j].len; i++) {

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

    }
}