malloc für Struktur und Zeiger in C

Angenommen, ich möchte eine Struktur definieren, die die Länge des Vektors und seine Werte darstellt, wie folgt:

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

Angenommen, ich möchte einen Vektor y definieren und ihm Speicher zuweisen.

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

Meine Suche im Internet zeigt, dass ich den Speicher für x separat zuweisen sollte.

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

Aber es scheint, dass ich den Speicher für y-> x zweimal zuweise, einen, während ich Speicher für y und den anderen, während ich Speicher für y-> x zuweise, und es scheint eine Verschwendung von Speicher zu sein. Es wird sehr geschätzt, wenn Sie mich wissen lassen, was Compiler wirklich tun und wie der richtige Weg wäre, um sowohl y als auch y->x zu initialisieren.

Danke im Voraus.

Nein, du bist nicht Speicher zuweisen für y->x zweimal.

Stattdessen weisen Sie Speicher für die Struktur zu (die einen Zeiger enthält). Plus etwas, auf das dieser Zeiger zeigen soll.

Denk darüber so:

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

Die braucht man eigentlich zwei Zuweisungen (1 und 2), um alles zu speichern, was Sie brauchen.

Außerdem sollte Ihr Typ sein struct Vector *y da es sich um einen Zeiger handelt und Sie den Rückgabewert niemals umwandeln sollten malloc in C.

Es kann bestimmte Probleme verbergen, die Sie nicht verbergen möchten, und C ist perfekt in der Lage, die implizit zu konvertieren void* Rückgabewert an jeden anderen Zeiger.

Und natürlich möchten Sie wahrscheinlich die Erstellung dieser Vektoren kapseln, um ihre Verwaltung zu vereinfachen, z. B. indem Sie Folgendes in einer Header-Datei haben vector.h:

struct Vector {
    double *data;    // Use readable names rather than x/n.
    size_t size;
};

struct Vector *newVector(size_t sz);
void delVector(struct Vector *vector);
//void setVectorItem(struct Vector *vector, size_t idx, double val);
//double getVectorItem(struct Vector *vector, size_t idx);

Dann in vector.chaben Sie die eigentlichen Funktionen zur Verwaltung der Vektoren:

#include "vector.h"

// Atomically allocate a two-layer object. Either both layers
// are allocated or neither is, simplifying memory checking.

struct Vector *newVector(size_t sz) {
    // First, the vector layer.

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

    // Then data layer, freeing vector layer if fail.

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

    // Here, both layers worked. Set size and return.

    vector->size = sz;
    return vector;
}

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

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

Indem Sie die Vektorverwaltung so kapseln, stellen Sie sicher, dass Vektoren entweder vollständig oder gar nicht erstellt werden – ja nein Wahrscheinlichkeit, dass sie halb gebaut sind.

Es ermöglicht Ihnen auch, die zugrunde liegenden Datenstrukturen in Zukunft vollständig zu ändern, ohne Clients zu beeinträchtigen. Zum Beispiel:

• wenn Sie sie zu spärlichen Arrays machen wollten, um Speicherplatz gegen Geschwindigkeit einzutauschen.
• wenn Sie möchten, dass die Daten bei jeder Änderung im dauerhaften Speicher gespeichert werden.
• wenn Sie sicherstellen möchten, dass alle Vektorelemente auf Null initialisiert wurden.
• wenn Sie die Vektorgröße aus Effizienzgründen von der Vektorkapazität trennen wollten⁽¹⁾.

Sie können bei Bedarf auch weitere Funktionen hinzufügen, z. B. das sichere Festlegen oder Abrufen von Vektorwerten (siehe kommentierten Code in der Kopfzeile).

Beispielsweise könnten Sie (als eine Option) Einstellungswerte außerhalb des gültigen Bereichs stillschweigend ignorieren und Null zurückgeben, wenn Sie diese Werte erhalten. Oder Sie könnten einen Fehler irgendeiner Art melden oder versuchen, den Vektor unter der Decke automatisch zu erweitern⁽¹⁾.

In Bezug auf die Verwendung der Vektoren ist ein einfaches Beispiel wie folgt (sehr einfach) main.c

#include "vector.h"

#include <stdio.h>

int main(void) {
    Vector myvec = newVector(42);
    myvec.data[0] = 2.718281828459;
    delVector(myvec);
}

⁽¹⁾ Dieses Potenzial für einen erweiterbaren Vektor bedarf weiterer Erklärung.

Viele Vektorimplementierungen trennen die Kapazität von der Größe. Ersteres gibt an, wie viele Elemente Sie verwenden können, bevor eine Neuzuweisung erforderlich ist, letzteres ist die tatsächliche Vektorgröße (immer <= die Kapazität).

Beim Erweitern möchten Sie im Allgemeinen so erweitern, dass Sie es nicht viel tun, da dies eine teure Operation sein kann. Sie könnten beispielsweise 5 % mehr hinzufügen, als unbedingt erforderlich ist, damit in einer Schleife, die kontinuierlich ein Element hinzufügt, es nicht für jedes einzelne Element neu zuweisen muss.

Beim ersten Mal weisen Sie Speicher zu Vectorwas die Variablen bedeutet x,n.

Jedoch x deutet noch nichts brauchbares an.

Deshalb also eine zweite Zuordnung ist ebenfalls erforderlich.

Im Prinzip machst du es schon richtig. Für das, was Sie wollen, brauchen Sie zwei malloc()s.

Nur einige Kommentare:

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

sollte sein

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

In der ersten Zeile weisen Sie Speicher für ein Vector-Objekt zu. malloc() gibt einen Zeiger auf den zugewiesenen Speicher zurück, also muss y ein Vektorzeiger sein. In der zweiten Zeile weisen Sie Speicher für ein Array von 10 Doubles zu.

In C brauchen Sie die expliziten Umwandlungen und das Schreiben nicht sizeof *y Anstatt von sizeof(struct Vector) ist besser für die Typsicherheit und spart außerdem Tipparbeit.

Sie können Ihre Struktur neu anordnen und eine einzelne ausführen malloc() so:

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

Wenige Punkte

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

es sollte sein struct Vector *y = (struct Vector*)malloc(sizeof(struct Vector)); seit y hält Zeiger auf struct Vector.

1 malloc() weist nur genügend Speicher zu, um die Vektorstruktur zu halten (die ein Zeiger auf double + int ist)

2 malloc() Weisen Sie tatsächlich Speicher zu, um 10 doppelt zu halten.

Wenn Sie Speicher zuweisen für struct Vector Sie weisen nur Speicher für den Zeiger zu x, dh für Leerzeichen, wo sein Wert, der Adresse enthält, platziert wird. Auf diese Weise weisen Sie dem Block also keinen Speicher zu, auf dem y.x wird verweisen.

Zuerst weist malloc Speicher für struct zu, einschließlich Speicher für x (Zeiger auf double). Der zweite malloc weist Speicher für den doppelten Wert zu, auf den x zeigt.

Sie könnten dies tatsächlich in einem einzigen Malloc tun, indem Sie den Vektor und das Array gleichzeitig zuweisen. Z.B:

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

Dies weist den Vektor ‘y’ zu und lässt dann y->x auf die extra zugewiesenen Daten unmittelbar nach der Vektorstruktur zeigen (jedoch im selben Speicherblock).

Wenn eine Größenänderung des Vektors erforderlich ist, sollten Sie dies wie empfohlen mit den beiden Zuordnungen tun. Das interne y->x-Array könnte dann in der Größe geändert werden, während die Vektorstruktur ‘y’ intakt bleibt.