Warum ist es sicherer, sizeof(*pointer) in malloc zu verwenden

Gegeben

struct node
{
     int a;
     struct node * next;
};

Um eine neue Struktur zu mallocieren,

struct node *p = malloc(sizeof(*p));

ist sicherer als

struct node *p = malloc(sizeof(struct node));

Wieso den? Ich dachte, sie sind gleich.

Es ist sicherer, weil Sie den Typnamen nicht zweimal erwähnen müssen und nicht die richtige Schreibweise für die „dereferenzierte“ Version des Typs erstellen müssen. Zum Beispiel müssen Sie nicht “die Sterne zählen”.

int *****p = malloc(100 * sizeof *p);

Vergleichen Sie das mit dem typbasierten sizeof in

int *****p = malloc(100 * sizeof(int ****));

wo Sie sicherstellen müssen, dass Sie die richtige Anzahl von verwendet haben * unter sizeof.

Um zu einem anderen Typ zu wechseln, müssen Sie nur eine Stelle ändern (die Deklaration von p) statt zwei. Und Menschen, die die Gewohnheit haben, das Ergebnis zu werfen malloc drei Plätze wechseln müssen.

Generell ist es sehr sinnvoll, sich an die folgende Richtlinie zu halten: Typnamen gehören in Deklarationen und nirgendwo anders hin. Die eigentlichen Anweisungen sollten typunabhängig sein. Sie sollten es so weit wie möglich vermeiden, Typnamen zu nennen oder andere typspezifische Merkmale zu verwenden.

Letzteres bedeutet: Vermeiden Sie unnötige Besetzungen. Vermeiden Sie unnötige typspezifische konstante Syntax (wie 0.0 oder 0L wo eine Ebene 0 würde genügen). Vermeiden Sie die Erwähnung von Typnamen unter sizeof. Usw.

Denn wenn zu einem späteren Zeitpunkt p wird gemacht, um auf einen anderen Strukturtyp zu zeigen, als Ihre Speicherzuweisungsanweisung verwendet malloc muss sich nicht ändern, es weist immer noch genug Speicher zu, der für das Neue erforderlich ist Typ. Es gewährleistet:

• Sie müssen die Speicherzuweisungsanweisung nicht jedes Mal ändern, wenn Sie die ändern Typ es weist Speicher zu.
• Ihr Code ist robuster und weniger anfällig für manuelle Fehler.

Im Allgemeinen ist es immer eine gute Praxis, sich nicht auf konkrete Typen zu verlassen, und die erste Form tut dies einfach, sie codiert einen Typ nicht fest.

Es ist praktisch, weil Sie dies umwandeln können:

struct node *p= malloc(sizeof(*p));

Das mögen:

#define MALLOC(ptr)   (ptr) = malloc(sizeof(*(ptr) ))

struct node *p;
MALLOC(p);

Oder für ein Array:

#define MALLOC_ARR(ptr, arrsize) \
       (ptr) = malloc(sizeof(*(ptr) ) * arrsize)

struct node *p;
MALLOC_ARR(p, 20);

Und warum ist das sicher? Weil der Benutzer, der diese Makros verwendet, weniger wahrscheinlich Fehler macht, die von AndreyT beschrieben wurden, genau wie im Fall von DIM() um die Größe eines statischen Arrays zu erhalten.

#define DIM(arr)   ((sizeof(arr))/(sizeof(arr[0])))

Dies ist auch sicherer, da der Benutzer die statische Array-Größe nicht an mehreren Stellen konsistent machen muss. Stellen Sie die Array-Größe an einer Stelle ein und verwenden Sie dann einfach die DIM() und du bist fertig! Der Compiler erledigt das für Sie.