Zuweisungen

Die Themen:

Zuweisungen von numerischen Daten
Zuweisungen von Zeichen- und String-Literalen
Mehrfach-Zuweisungen
Beispiel und Übung

Zuweisungen von numerischen Daten

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

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 long Wert 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!)

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.

Wollen Sie ein String-Literal einer Variable zuweisen, so muss die Variable den Datentyp Zeiger auf const char besitzen. 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!";

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!

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 letterA wird 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 ansehen!