sizeof mit einem Typ oder einer Variablen

Kürzlich sah ich jemanden, der einen anderen Benutzer für die Verwendung von sizeof var anstelle von sizeof(type) lobte. Ich dachte immer, das sei nur eine Stilentscheidung. Gibt es einen signifikanten Unterschied? Als Beispiel wurden die Zeilen mit f und ff als besser angesehen als die Zeilen mit g und gg:

 typedef struct _foo {} foo;

 foo *f = malloc(count * sizeof f);
 foo *g = malloc(sizeof(foo) * count);

 foo **ff = malloc(count * sizeof *ff);
 foo **gg = malloc(sizeof(foo*) * count);

Meiner Meinung nach ist das erste Set nur eine Frage des Stils. Aber im zweiten Zeilenpaar kann die zusätzliche Sekunde * leicht mit einer Multiplikation verwechselt werden.

Wenn der Typ der Variablen geändert wird, muss sizeof nicht geändert werden, wenn die Variable das Argument und nicht der Typ ist.

In Bezug auf den Kommentar von @icepack: Die Möglichkeit oder Wahrscheinlichkeit einer Änderung des Typs gegenüber dem Variablennamen ist nicht das Problem. Stellen Sie sich vor, der Variablenname wird als Argument für sizeof verwendet und später geändert. Im besten Fall ändert eine Refactor-Rename-Operation alle Vorkommen und es wird kein Fehler eingeführt. Im schlimmsten Fall wird eine Instanz eines sizeof übersehen und der Compiler beschwert sich und Sie beheben es. Wenn der Typ geändert wird, sind Sie fertig, keine Möglichkeit von Fehlern bei sizeof-Anweisungen.

Stellen Sie sich nun vor, dass der Typ das Argument für sizeof ist. Wenn der Typ der Variablen geändert wird, gibt es keine andere Möglichkeit als die Überprüfung, um alle Größen zu finden, die sich auf diese Variable beziehen. Sie können suchen, aber Sie erhalten Treffer für alle nicht verwandten Verwendungen von sizeof desselben Typs. Wenn eine fehlt, haben Sie ein Laufzeitproblem aufgrund eines Größenunterschieds, der viel schwieriger zu finden ist.

Lassen Sie mich zusätzlich zu dem, was Steve sagt, hinzufügen, dass sizeof seinen Operanden nicht auswertet. Sie können also alles darin tun. Sie können nicht nur noch nicht initialisierte Variablen verwenden, sondern auch einen Nullzeiger dereferenzieren, nicht definierte, sondern nur deklarierte Funktionen aufrufen und andere Dinge tun. Ich ermutige Sie, immer die Ausdrucksversion zu verwenden, aus Gründen, die Steve großartig erklärt hat.

Denken Sie auch daran, dass Typnamen manchmal sehr lang und unlesbar sind, denken Sie nur an Zeiger auf Funktionen (insbesondere in C++). Anstatt zu schreiben sizeof(my_long_type<weird, stuff>) du tust es einfach sizeof t.

Möglicherweise sehen Sie einen kleinen Unterschied zwischen diesen:

foo **ff = malloc(count * sizeof *ff);
foo **gg = malloc(sizeof(foo*) * count);

..aber was ist, wenn die Zuordnung nicht in der Nähe der Deklaration liegt? Wenn ich auf eine Zeile stoße wie:

ff = realloc(ff, count * sizeof *ff);

dann bin ich ziemlich sicher, dass die Zeile richtig ist, ohne mich auch nur an die Art zu erinnern ff. Aber wenn ich das sehe:

ff = realloc(ff, count * sizeof(foo *));

Dann bin ich vielleicht etwas misstrauisch und muss nach der Art von suchen ff um mich zu beruhigen.

Die Zeilen f und ff sind definitiv schlechter als g und gg. sizeof f ist die Zeigergröße, da f ein Punkt ist. Um sie gleichwertig zu machen, müssten Sie schreiben sizeof *f (oder zur besseren Lesbarkeit sizeof(*f)).

Ich neige dazu zu verwenden sizeof(type) in der Speicherzuweisung, aber immer sizeof(variable) bei Verwendung einer lokalen oder globalen Variablen. Dennoch ist es klug, immer den Variablennamen zu verwenden.

Ich hatte auch eine lange Diskussion (manchmal ziemlich angeregt, und sie dauerte mehrere Tage – wir waren uns schließlich einig, dass wir uns in dieser Frage nicht einig waren) darüber, ob die Verwendung in Ordnung ist sizeof(variable) oder ob es sein muss sizeof variable; das heißt, spielt es eine Rolle, ob Klammern das Argument umschließen sizeof. Ich bin noch nie auf einen Compiler gestoßen, über den gewittert wird sizeof(variable)also entscheide ich mich für Einheitlichkeit und verwende immer die Klammern mit sizeof. Mein Kollege bestand ebenso darauf, dass Klammern nicht mit Variablen verwendet werden dürfen; dass es irgendwie einen wertvollen Unterschied zwischen der Notation mit und ohne Klammern gibt / gab. Ich bin nicht überzeugt worden – ich erwarte nicht, überzeugt zu werden.

Auf einem ganz anderen Kurs, ein paar andere Punkte darüber sizeof:

• Wenn Sie C99 und VLA (Arrays mit variabler Länge) verwenden, dann sizeof(vla) ist keine Kompilierzeitkonstante. In acht nehmen!
• Der C-Präprozessor versteht das nicht sizeof das ist ärgerlich, aber logisch.

Das Ermitteln der Größe einer Variablen kann zu unerwarteten Ergebnissen führen. Wenn die Variable ein Array ist, gibt sizeof(array) die Größe des Arrays zurück, nicht die Größe eines einzelnen Elements oder die Größe eines Zeigers. Wenn Sie die Größe eines Zeigers nehmen, wird die Größe eines Zeigers zurückgegeben. Aber da Arrays normalerweise als Zeiger dargestellt werden, wenn sie herumgereicht werden, kann die Sache verwirrend werden.

Die Geschäftslogik bestimmt Ihre Wahl.

1. Wenn sich Ihr Code auf eine bestimmte Variable bezieht und Ihr Code ohne diese Variable keinen Sinn macht – wählen Sie sizeof(var)

2. Wenn Sie Code mit einer Reihe von Variablen mit einem bestimmten Typ zu tun haben – wählen Sie sizeof(type). Normalerweise benötigen Sie dies, wenn Sie eine haben typedef die viele Variablen definiert, die Sie aufgrund ihres Typs (z. B. Serialisierung) unterschiedlich verarbeiten. Möglicherweise wissen Sie nicht, welche dieser Variablen in zukünftigen Codeversionen verbleiben werden, daher ist die Auswahl von type als Argument logisch korrekt. Auch das Wechseln solcher typedef wird Ihre nicht beeinträchtigen sizeof Linie.