Was passiert, wenn ich bei einer Variable den falschen Datentypen angebe (C++)?

8 Antworten

C++ verhält sich bei Initialisierungen, Zuweisungen und (impliziten) Typkonvertierungen teilweise sehr anders als C. Außerdem verhalten sich ältere C++ Versionen auch noch etwas anders als neue C++ Versionen.

Das schreibe ich jetzt nur, weil ich mich im Folgenden ausschließlich auf modernes C++ ab 2011 beziehen werde, um das es dir ja vermutlich in deiner Frage geht. Also meine Aussagen bitte nicht Eins zu Eins auf C oder altes C++ übertragen! :)

Zu allererst, solltest du deinen Code absichtlich möglichst strikt kompilieren, um so viele (mehr oder weniger) leicht verständliche oder zumindest informative Meldungen vom Compiler zu erhalten.

Beim GCC oder Clang geht das mit den entsprechenden Flags so (Beim ICC so ähnlich, bei VC++ aber ziemlich anders, siehe dazu MSDN evtl. über Google):

-std=c++11 -Wall -Wextra -Wpedantic -Werror

Damit sagst du dem Compiler (in dieser Reihenfolge), welche Version von C++ du eigentlich nutzen willst, schaltest alle a) gängigen, b) zusätzlichen und c) kleinkarierten Warnungen ein, und behandelst sämtliche Warnungen als Fehler.

Das zwingt dich dazu, ordentlichen / sauberen / portablen / fehlerarmen / korrekten Code zu schreiben. (Ich persönliich nutze noch viel mehr Compilerflags, aber normalerweise wird das dann so strikt, dass kein Drittcode mehr damit kompiliert.)

Das Gleichheitszeichen ist bei C++ etwas verwirrend gewählt, weil damit nämlich zwei Operatoren gemeint sind: Initialisierung und Zuweisung, was ziemlich unterschiedliche Dinge sind.

Aus diesem Grunde verwendet man bei modernem C++ geschweifte Klammern für die Initialisierung, die sich in vielen Aspekten von der "herkömmlichen" Zuweisung mit Gleichheitszeichen stark unterscheiden. Der für deine Frage hier relevanteste Unterschied dürfte sein, dass es keine implizite Umwandlung von Werten gibt, falls es zu einem Verlust an Informationen kommen könnte.

Beispiel für Initialisierungen:

int a = 3; // herkömmliche Zuweisung
int b = 3.14; // implizites Abschneiden des Nachkommateils
int c { 3.14 }; // Compilerfehler
int d { 3 }; // moderne Initialisierung
int e { static_cast<int>(3.14) }; // merkwürdig, aber legitim

Die Regeln für die Typkonvertierungen bei Zuweisungen und Operationen würden hier bei weitem den Rahmen sprengen, weshalb ich hier einfach mal auf die entsprechenden Kapitel in Fachbüchern verweise. Als Übersicht sollte dir das hier aber erst mal genügend:

https://en.cppreference.com/w/cpp/language/implicit_conversion

Naja, muss jetzt weg und hier abbrechen ...

Viel Spaß noch mit C++! :)

Nachtrag: Keine meiner obigen Aussagen erhebt den Anspruch an Vollständigkeit. Im Gegenteil: Ich weise darauf hin, dass ich alle Themen bewusst (!) nur grob angeschnitten habe! Besonders das Thema "Initialisierung" ist gerade bei C++ nichts, was man ausreichend in einer Antwort auf GF beantworten könnte.

Wenn du mal etwas fortgeschritten bist, lies dir unbedingt die Bücher "The C++ Programming Language" von Bjarne Stroustrupp und / oder "C++ Primer" von Stanley Lippman durch. Alles, was du vor diesen Büchern über C++ zu wissen geglaubt hast, ist (höchstwahrscheinlich zu großen Teilen) Pippifax und Anfängerkram. ;)

Gerade bei der Vorinitialisierung von Variablen mit float/double-Werten gibt es Konstellationen, bei denen tatsächlich Compiler wie z. B. der gcc ohne jegliche Warnung eine verlustbehaftete Konversion durchführen. Sogar wenn man mit "-Wall" übersetzt kommt bei etlichen gcc-Versionen keine Warnung dafür raus.

Die Vorbelegung einer int-Variable mit einer Fließkommazahl gehört leider genau zu diesen Stellen.

Die Deklaration "int i=2.345;" wird also führen, dass implizit eine verlustbehaftete Konversion von 2.345 nach 2 durchgeführt wird, und die Variable "i" eben mit dem ganzzahligen Wert 2 vorbelegt wird.

Aus diesem Grund werden Variablen nicht mit "=" initialisiert, sondern mit {...0}

int zahl{2.345};

ergibt auf jeden Fall einen Fehler(!) beim Compilieren.

Was möchtest Du wissen?