Die Zuweisung von Konstanten und Variablen oder eines Ausdrucks an eine Variable erfolgt mit dem Zuweisungsoperator =.

Zuweisungen von numerischen Daten

Die Zuweisung von Konstanten und Variablen oder eines Ausdrucks an eine Variable erfolgt mit dem Zuweisungsoperator =.

Beachten Sie, dass im weiteren Verlaufe dieser Lektion davon ausgegangen wird, dass eine short Variablen 2 Bytes und eine long Variable 4 Bytes belegt. Wie bereits erwähnt, kann dies je nach System/Compiler durchaus anders sein. Jedoch ändert sich dadurch nichts am grundsätzlichen Verhalten der nachfolgend beschriebenen Konvertierung (Anpassung) von unterschiedlichen Datentypen.

Bei der Durchführung einer Zuweisung von numerischen Daten an eine Variable müssen drei Fälle unterschieden werden:

1. Die Datentypen links und rechts des Operators = sind gleich

In diesem Fall müssen bei der Zuweisung keine Anpassungen vorgenommen werden und die Zuweisung erfolgt ohne Informationsverlust.

2. Linker Operand besitzt größeren Wertebereich als rechter Operand und beide Datentypen sind jedoch mit oder ohne Vorzeichen (signed bzw. unsigned).

In diesem Fall wird der rechte Operand durch den Compiler automatisch vorzeichenrichtig erweitert und es geht somit keine Information verloren (automatische Typkonvertierung). Dies wird besonders deutlich bei der ersten Zuweisung im Beispiel, bei der eine short Variable einer long Variable zugewiesen wird.

// Zuweisung einer short Variable an eine long Variable short sVal = -10;    // = 0xFFF6 long  lVal = sVal;   // = 0xFFFFFFF6 //Zuweisung einer unsigned char Variable an eine unsigned long Variable unsigned char bVal  = 128;    // = 0x80 unsigned long dwVal = bVal;   // = 0x00000080

3. Linker Operand besitzt kleineren Wertebereich als rechter Operand oder beiden Datentypen besitzen unterschiedliche ‚Vorzeichen-Datentypen‘ (unsigned nach signed oder umgekehrt).

Dieses ist der kritische Fall! In beiden Fällen werden die Bytes des rechten Operanden einfach in den linken Operanden kopiert und zwar beginnend mit dem niederwertigsten Byte. Die Anzahl der zugewiesenen Bytes richtet sich dabei selbstverständlich nach der Größe des linken Operanden. D.h. wenn Sie einer char-Variable einen longWert zuweisen, so wird nur das niederwertigste Byte des long Werts übernommen. Ein guter Compiler gibt aber in diesen Fällen eine Warnung aus, die Sie selbstverständlich auch ernst nehmen sollten. Sonst kann es, wie im Beispiel bei der letzten Zuweisung, zu recht seltsamen Ergebnissen führen.

// Zuweisung einer long Variable an eine short Variable long  lVal = -186L;   // = 0xFFFFFF46 short wVal = lVal;    // = 0xFF46 = -186 // Zuweisung einer unsigned long Variable an eine unsigned char Variable unsigned long dwVal = 128UL;   // = 0x00000080 unsigned char bVal  = dwVal;   // = 0x80 // Aber Achtung! Zuweisung einer unsigned long Variable an eine char Variable unsigned long dwVal = 128UL   // 0x00000080 char          cVal  = dwVal;  // 0x80 = -128 (Vorzeichen!)

Bei der Konvertierung einer Gleitkommazahl in eine Ganzzahl werden zusätzlich noch die Nachkommastellen einfach abgeschnitten, d.h. es erfolgt keine automatische Rundung.

Zuweisungen von Zeichen- und String-Literalen

Die Zuweisung von Zeichen- und String-Literalen erfolgt prinzipiell gleich wie die Zuweisung von numerischen Daten. Lediglich beim Datentyp der linken Operanden müssen Sie acht geben.

Die nachfolgenden Ausführungen folgen der Richtlinie: die Datentypen bei Zuweisungen sollten links und rechts des Gleichheitszeichens identisch sein.

Wenn ein Zeichen-Literal einer Variable zugewiesen werden soll, so sollte die Variable vom Datentyp char sein. Das zuzuweisende Zeichen wird in einfache Hochkomma eingeschlossen, so wie in der Lektion Konstanten dargestellt. Das Gleiche gilt auch für wide-character Zeichen. Der Datentyp der Variable sollte hier wchar_t sein und das zuzuweisende Zeichen wird ebenfalls in Hochkomma eingeschlossen und ist mit dem Präfix L zu versehen. Weisen Sie ein Zeichen einem anderen Datentyp als char zu, so erfolgt wie bei numerischen Daten eine entsprechende Typkonvertierung vom Datentyp char aus.

Beachten Sie bitte, dass hier der Datentyp char verwendet wird und nicht signed char bzw. unsigned char. Diese drei Datentypen sind nicht identisch. Nur wenn sizeof(char) gleich sizeof(signed char) bzw. sizeof(unsigned char) ist erfolgt die Zuweisung ohne Informationsverlust.

Wollen Sie ein String-Literal einer Variable zuweisen, so muss die Variable den Datentyp Zeiger auf const charbesitzen. Um einen const char-Zeiger zu definieren, geben Sie nach dem Datentyp const char und vor dem Variablennamen ein * (Sternchen) ein, so wie im nachfolgenden Beispiel dargestellt. Anschließend können Sie dann das in Anführungszeichen eingeschlossene String-Literal diesem Zeiger zuweisen. Sie können diesem Zeiger später im Programmverlauf durchaus ein weiteres String-Literal zuweisen, da hier nicht der Zeiger konstant ist sondern das, worauf er zeigt, also das String-Literal. Mehr zu Zeigern später im Kurs.

// Zuweisungen von Zeichen char charA = ‚A‘;    // = 0x41 char linef = ‚\n‘;   // = 0x0A // Zuweisungen von wide character wchar_t chA = L’A‘;   // = 0x0041 wchar_t lf  = L’\n‘;  // = 0x000A // Zuweisungen von Strings const char *pText;    // const char-Zeiger pText = „Dies ist ein String!“;

Aus Gründen der Abwärtskompatibilität mit älteren Programmen ist es auch erlaubt, ein String-Literal einem char-Zeiger zuzuweisen. char *pText = „String-Literal“; Bei neueren Programmen ist diese Zuweisung aber unbedingt zu vermeiden. Sie ist nur ein ‚Tribut‘ des C++ Standards an bereits bestehende (alte C) Programme. Sollte Sie Programme für Microcontroller schreiben (so genannte Embedded Systems), dann kann dies unter Umständen zu nicht ungewolltem Verhalten führen, da String-Literale in der Regel im ROM (read-only memory) abgelegt werden.

Mehrfach-Zuweisungen

Außer diesen einfachen Zuweisungen können auch Mehrfach-Zuweisungen verwendet werden. Hierbei kann dann mehreren Variablen in einer Anweisung der gleiche Wert zugewiesen werden. Die einzelnen Variablen werden mit dem Zuweisungsoperator verkettet und ganz rechts wird der zuzuweisende Wert (Konstante oder weitere Variable) angegeben. Die Zuweisungen erfolgen dann in der Reihenfolge von rechts nach links.

// Variablendefinitionen short sVar1, sVar2; char cVar; // Zuweisungen sVar1 = sVar2 = 0xFF;    // Ergebnis: sVar2=255, sVar1=255 sVar1 = cVar = 0xFF;     // Ergebnis: cVar=-1, sVar1=-1 cVar = sVar1 = 0xFF;     // Ergebnis: sVar1=255, cVar=-1!

Vermeiden Sie bei Mehrfach-Zuweisungen unbedingt die Verwendung von unterschiedlichen Datentypen. Dies kann sonst, wie in der letzten Zuweisung oben dargestellt, zu unliebsamen Überraschungen führen.

Beispiel und Übung

Beispiel: Innerhalb von main() wird die Gleitkomma-Konstante PI definiert und mit dem Wert 3.1416 belegt. Die Konstante PI wird dann der int-Variable intPi zugewiesen, um so den ganzzahligen Anteil von PI zu erhalten. Anschließend wird intPi ausgegeben. Danach wird eine char-Variable letterA definiert und mit dem Buchstaben ‚A‘ initialisiert. Der Inhalt von letterAwird dann einmal als char-Variable, einmal als Dezimalwert und einmal als Hexadezimalwert ausgegeben. Beachten Sie, dass der Inhalt von char-Variablen standardmäßig als ASCII-Zeichen interpretiert wird. Um eine char-Variable als numerischen Wert auszugeben, müssen Sie eine entsprechende explizite Typkonvertierung vornehmen. Im Beispiel wird der char-Wert dazu in einen int-Wert konvertiert. Mehr zu Typkonvertierung später im Kurs. Der Integerteil von Pi ist: 3 Inhalt der Variable ‚letterA‘ ist: A Und ‚letterA‘ als Wert: 65 In Hex-Darstellung: 0x41 // Beispiel zu Zuweisungen #include <iostream> using std::cout; using std::endl; int main() { // Definition der Konstanten PI const double PI = 3.1416; // Definition einer int Variable und den ganzzahligen Teil // von Pi zuweisen. Die Warnung beim Übersetzen, dass hier //ein const double einem int zugewiesen wird kann ausnahmsweise // ignoriert werden  int intPi = PI; cout << „Der Integerteil von Pi ist: “ << intPi << endl; // char-Variable definieren und gleich // mit dem Buchstaben A initialisieren char letterA = ‚A‘; cout << „Inhalt der Variable ‚letterA‘ ist: “ << letterA << endl; // Inhalt der char-Variable als Wert ausgeben cout << „Und ‚letterA‘ als Wert: “ << static_cast<int>(letterA) << endl; cout << „In Hex-Darstellung: “ << std::hex << std::showbase << static_cast<int>(letterA) << endl; } Übung: Definieren Sie eine short Variable shortValue und initialisieren diese bei ihrer Definition mit dem Hex-Wert 7fff. Geben Sie die short Variable als Dezimalzahl aus. Definieren Sie eine char Variable charValue und weisen Sie ihr die Variable shortValue zu. Definieren Sie eine long Variable longValue und weisen Sie ihr die Variable shortValue zu. Geben Sie die char Variable und long Variable in dezimal aus. Welche Werte erhalten Sie und warum? ??? Die sollen Sie selbst herausbekommen ??? Lösung zur Lektion „Zuweisungen“ // Lösung zu Zuweisungen #include <iostream> using namespace std; int main() { // short Variable mit Hex-Wert initialisieren und dezimal ausgeben short shortValue = 0x7fff; cout << „short-Wert 0x7fff ist in dezimal: “ << shortValue << endl; // short Variable einer char-Variable zuweisen // erzeugt -1, da nur der niederwertige Anteil uebernommen wird // 0xFF gleich -1 in dezimal char charValue = shortValue; // char Variable dann einer long Variable zuweisen // Hier erfolgt eine vorzeichenrichtige Erweiterung long longValue = shortValue; // char und long Variable ausgeben // Achtung! Bei char-Variable ist eine Typkonvertierung // notwendig, da char-Variable sonst als ASCII-Zeichen ausgeben wird cout << „charValue: “ << static_cast<int>(charValue) << endl; cout << „longValue: “ << longValue << endl; }

C++ Kurs von Wolfgang Schröder

http://www.cpp-tutor.de/cpp/index.html

C++ Tutorial von Toni Schornböck (Shade Of Mine)

http://tutorial.schornboeck.net/inhalt.htm

C++ Tutorial von Volkard Henkel

http://www.volkard.de/vcppkold/inhalt.html

Correct C++ tutorial von Alf P. Steinbach

http://home.no.net/dubjai/win32cpptut/html/

Disclaimer: Der Autor/Sprecher übernimmt keinerlei Gewähr für die Aktualität, Korrektheit, Vollständigkeit oder Qualität der bereitgestellten Informationen. Haftungsansprüche gegen den Verfasser, welche sich auf Schäden materieller oder ideeller Art beziehen, die durch die Nutzung der dargebotenen Informationen bzw. durch die Nutzung fehlerhafter und unvollständiger Informationen verursacht wurden, sind grundsätzlich im weitest zulässigen Rahmen ausgeschlossen. Der Artikel bzw. das Video stellt in keiner Art und Weise eine professionelle Anlage-, Investitions-, Vermögens-, Steuerberatung dar und ersetzt diese auch nicht. In diesem Artikel bzw. das Video werden keine Garantien oder Versprechungen zu Gewinnen gemacht. Alle Aussagen in diesem und anderen Artikel bzw. Video auf Bitfantastic.com und über den dazugehörigen Youtube Kanal entsprechen meiner subjektiven Meinung. Bitfantastic.com ist eine Informationsplattform zur innovativen Blockchain-Technologie. Aufgezeigt werden Anwendungsfälle, Vorteile, Nachteile, Kritische Betrachtungen, Ökonomische und Wirtschaftliche Auswirkungen sowie Chancen und Risiken für die Gesellschaft. Kryptowährungen sind nicht gleich Blockchain! Die Schöpfung virtueller Währungseinheiten (Kryptowährungen) erfolgt im Gegensatz zu den Währungen der Noten- und Geschäftsbanken über private Computernetzwerke. Eine Idee der nichtstaatlichen Ersatzwährung. (laut BaFin) Es handelt sich um höchst spekulative Vorgänge mit der Möglichkeit des Totalverlustes!