struct指针作为返回类型

Question

I want to print kk[i].data[j] but it is not printing at all.

intarr_save_binary is returning 2. I expect to get 0.

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

Did I properly allocate the memory?

#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;

    }
}

This zeroes ia[0].data on the very first pass through the double loop. ( ia[0].data = (0 + 1) * 0 gives 0 ).

Thus ia->data is 0 , and !ia->data is true, making the function return 2 .

---

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

You obviously expect sizeof kk to give the total amount of memory allocated for kk .

And that is what you get, actually -- the total amount of memory allocated for intarr_t * , which is the type of kk at that point. That most likely results in 4 or 8, depending on your architecture. What it is not is whatever len * sizeof(int) resulted in when you called intarr_create() . As @BoPersson commented, if you allocate the memory yourself, you have to remember yourself how much you allocated.

The sizeof kk / sizeof kk[0] "trick" only works if kk actually is an array , ie if it has been declared as such within the scope of you using the sizeof operator on it so the compiler can "see" its size.

So, as you have an int and an int * in your struct kk[0] , which together are very likely to require more memory than an intarr_t * , the integer division results in 0 .

---

You might also take note that free() is not recursive. With free(kk) , you are leaking all the memory you allocated for all the data members. For every malloc() , there needs to be a corresponding free() . (And it does matter even if the program ends right after that one free() , as not all operating systems can / will protect you from this error.)