malloc dla struktury i wskaźnika w C

Załóżmy, że chcę zdefiniować strukturę reprezentującą długość wektora i jego wartości jako:

struct Vector{
    double* x;
    int n;
};

Teraz przypuśćmy, że chcę zdefiniować wektor y i przydzielić mu pamięć.

struct Vector *y = (struct Vector*)malloc(sizeof(struct Vector));

Moje wyszukiwania w Internecie pokazują, że powinienem przydzielić pamięć dla x osobno.

y->x = (double*)malloc(10*sizeof(double));

Ale wydaje się, że przydzielam pamięć dla y-> x dwa razy, jeden podczas przydzielania pamięci dla y, a drugi podczas przydzielania pamięci dla y-> x, i wydaje się, że jest to marnowanie pamięci. Byłoby bardzo wdzięczne, gdybyśmy wiedzieli, co naprawdę robi kompilator i jaki byłby właściwy sposób inicjalizacji zarówno y, jak i y-> x.

Z góry dziękuję.

Nie, nie przydzielasz pamięci y->xdwukrotnie.

Zamiast tego przydzielasz pamięć dla struktury (która zawiera wskaźnik) oraz coś, na co ten wskaźnik ma wskazywać.

Pomyśl o tym w ten sposób:

         1          2
        +-----+    +------+
y------>|  x------>|  *x  |
        |  n  |    +------+
        +-----+

Potrzebujesz więc dwóch alokacji ( 1i 2) do przechowywania wszystkiego.

Dodatkowo twój typ powinien być, struct Vector *yponieważ jest wskaźnikiem i nigdy nie powinieneś rzutować wartości zwracanej z mallocC, ponieważ może to ukryć pewne problemy, których nie chcesz ukryć - C jest w pełni zdolny do niejawnej konwersji void*zwracanej wartości na dowolny inny wskaźnik.

I oczywiście prawdopodobnie chcesz hermetyzować tworzenie tych wektorów, aby ułatwić zarządzanie nimi, na przykład:

struct Vector {
    double *data;    // no place for x and n in readable code :-)
    size_t size;
};

struct Vector *newVector (size_t sz) {
    // Try to allocate vector structure.

    struct Vector *retVal = malloc (sizeof (struct Vector));
    if (retVal == NULL)
        return NULL;

    // Try to allocate vector data, free structure if fail.

    retVal->data = malloc (sz * sizeof (double));
    if (retVal->data == NULL) {
        free (retVal);
        return NULL;
    }

    // Set size and return.

    retVal->size = sz;
    return retVal;
}

void delVector (struct Vector *vector) {
    // Can safely assume vector is NULL or fully built.

    if (vector != NULL) {
        free (vector->data);
        free (vector);
    }
}

Hermetyzując w ten sposób kreację, zapewniasz, że wektory są w pełni zbudowane lub w ogóle nie są zbudowane - nie ma szans, że zostaną zbudowane w połowie. Pozwala także w przyszłości całkowicie zmienić podstawowe struktury danych bez wpływu na klientów (na przykład, jeśli chcesz, aby były rzadkimi tablicami, aby wymienić miejsce na szybkość).

Za pierwszym razem, można przydzielić pamięć Vector, co oznacza zmienne x, n.

Jednak x nie wskazuje jeszcze niczego przydatnego .

Dlatego potrzebny jest również drugi przydział .

Kilka punktów

struct Vector y = (struct Vector*)malloc(sizeof(struct Vector)); jest źle

powinno być, struct Vector *y = (struct Vector*)malloc(sizeof(struct Vector));ponieważ yzawiera wskaźnik do struct Vector.

Pierwszy malloc()przydziela tylko tyle pamięci, aby pomieścić strukturę Vector (czyli wskaźnik do double + int)

2. malloc()faktycznie przydziel pamięć, aby pomieścić 10 podwójnych.

W rzeczywistości można to zrobić w jednym malloc, przydzielając wektor i tablicę w tym samym czasie. Na przykład:

struct Vector y = (struct Vector*)malloc(sizeof(struct Vector) + 10*sizeof(double));
y->x = (double*)((char*)y + sizeof(struct Vector));
y->n = 10;

To przydziela Vector 'y', a następnie wskazuje y-> x na dodatkowe przydzielone dane bezpośrednio po strukturze Vector (ale w tym samym bloku pamięci).

Jeśli wymagana jest zmiana rozmiaru wektora, należy to zrobić z dwoma alokacjami zgodnie z zaleceniami. Wewnętrzna tablica y-> x mogłaby być wtedy zmieniana, zachowując nienaruszoną strukturę wektora „y”.

W zasadzie już robisz to poprawnie. Na to, co chcesz, potrzebujesz dwóch malloc()sekund.

Kilka uwag:

struct Vector y = (struct Vector*)malloc(sizeof(struct Vector));
y->x = (double*)malloc(10*sizeof(double));

Powinien być

struct Vector *y = malloc(sizeof *y); /* Note the pointer */
y->x = calloc(10, sizeof *y->x);

W pierwszym wierszu przydzielasz pamięć dla obiektu Vector. malloc()zwraca wskaźnik do przydzielonej pamięci, więc y musi być wskaźnikiem Vector. W drugiej linii przydzielasz pamięć dla tablicy 10 podwójnych.

W C nie potrzebujesz jawnych rzutów, a pisanie sizeof *yzamiast tego sizeof(struct Vector)jest lepsze ze względu na bezpieczeństwo typów, a poza tym oszczędza na pisaniu.

Możesz zmienić układ swojej struktury i zrobić jedną malloc()taką:

struct Vector{    
    int n;
    double x[];
};
struct Vector *y = malloc(sizeof *y + 10 * sizeof(double));

Kiedy przydzielasz pamięć struct Vector, po prostu przydziel pamięć dla wskaźnika x, czyli miejsca, w którym zostanie umieszczona jego wartość zawierająca adres. W ten sposób nie przydziela się pamięci dla bloku, do którego y.xbędzie się odwoływać.

Najpierw malloc przydziela pamięć dla struct, w tym pamięć dla x (wskaźnik do double). Drugi malloc przydziela pamięć dla podwójnej wartości, na którą x punktów.

Kiedy malloc(sizeof(struct_name))automatycznie przydziela pamięć dla pełnego rozmiaru struktury, nie musisz zmieniać każdego elementu wewnątrz.

Użyj -fsanitize=addressflagi, aby sprawdzić, jak wykorzystałeś pamięć programu.