C++ Tutorial

Zuweisungen

Zuweisung von numerischen Daten

Die Zuweisung einer Konstante, Variable oder eines Ausdrucks an eine Variable erfolgt mit dem Zuweisungsoperator =.

Im weiteren Verlauf dieses Kapitels wird davon ausgegangen, dass eine short-Variable 2 Bytes und eine long-Variable 4 Bytes belegen. Wie erwähnt, kann dies je nach System/Compiler abweichen. Jedoch ändert sich dadurch nichts am grundlegenden Verhalten der nachfolgend beschriebenen Konvertierungen bei unterschiedlichen Datentypen.

Bei der Zuweisung sind drei Fälle zu unterscheiden:

1. Wertebereiche beider Operanden sind gleich.

In diesem Fall ist bei der Zuweisung keine Anpassung erforderlich und die Zuweisung erfolgt ohne Informationsverlust.

2. Linker Operand besitzt größeren Wertebereich als rechter Operand und beide Datentypen besitzen den gleich Vorzeichentyp.

In diesem Fall wird der rechte Operand durch den Compiler automatisch vorzeichenrichtig auf den Datentyp des linken Operanden erweitert und es geht keine Information verloren. Dies wird besonders deutlich bei der Zuweisung in Zeile 3 im Beispiel, in der eine short-Variable einer long-Variable zugewiesen wird.

1:	// Zuweisung short an long-Variable
2:	short sVal = -10;    // = 0xFFF6
3:	long  lVal = sVal;    // = 0xFFFFFFF6
4:
5:	//Zuweisung unsigned char an unsigned long-Variable
6:	unsigned char bVal  = 128;     // = 0x80
7:	unsigned long dwVal = bVal;   // = 0x00000080

3. Linker Operand besitzt kleineren Wertebereich als rechter Operand oder die Operanden besitzen einen unterschiedlichen Vorzeichentyp.

In diesem Fall wird der rechte Operand Byte für Byte in den linken Operanden kopiert, beginnend mit dem niederwertigsten Byte. Die Anzahl der kopierten Bytes richtet sich dabei nach der Größe des linken Operanden. D.h., wird einer char-Variable ein long-Datum zugewiesen, wird nur das niederwertige Byte des long-Datums übernommen. Dabei kann es, wie im Beispiel in Zeile 11 zu sehen ist, zu recht seltsamen Ergebnissen kommen.

1:	// Zuweisung long-Variable an eine short-Variable
2:	long  lVal = -186L;   // = 0xFFFFFF46
3:	short wVal = lVal;   // = 0xFF46 = -186
4:	
5:	// Zuweisung unsigned long an unsigned char-Variable
6:	unsigned long dwVal = 128UL;  // = 0x00000080
7:	unsigned char bVal  = dwVal;   // = 0x80
8:	
9:	// Achtung! Zuweisung unsigned long an char-Variable
10:	unsigned long dwVal = 128UL;   // 0x00000080
11:	signed char   cVal  = dwVal;      // 0x80 = -128 (Vorzeichen!)

Bei der Konvertierung eines Gleitkomma-Datums in ein Integer-Datum werden die Nachkommastellen abgeschnitten, d.h. es erfolgt keine Rundung.

Zuweisung von Zeichen- und String-Literalen

Wird ein Zeichen-Literal einer Variable zugewiesen, sollte die Variable vom Datentyp char sein. Das zuzuweisende Zeichen wird in Hochkommas eingeschlossen, wie im Kapitel Konstanten dargestellt. Das Gleiche gilt ebenfalls für wide-character Zeichen. Die Variable sollte dann vom Datentyp wchar_t sein und das zuzuweisende Zeichen ist mit dem Präfix L zu versehen. Wird ein Zeichen einem anderen Datentyp als char zugewiesen, erfolgt, wie bei numerischen Daten, eine Typkonvertierung vom Datentyp char aus.

Bei der Zuweisung eines String-Literals (String ohne Präfix) an eine Variable, muss die Variable den Datentyp Zeiger auf const char besitzen. Um einen const char-Zeiger zu definieren, folgt nach dem Datentyp const char und vor dem Variablennamen ein * (Sternchen), so wie im nachfolgenden Beispiel dargestellt. Dem Zeiger kann später im Programmverlauf ein weiteres String-Literal zugewiesen werden, da hier nicht der Zeiger konstant ist, sondern das, worauf er verweist, also das String-Literal. Mehr zu Zeigern später.

1:	// Zuweisungen von Zeichen
2:	char charA = 'A';    // = 0x41
3:	char linef = '\n';   // = 0x0A
4:	
5:	// Zuweisungen von wide character
6:	wchar_t chA = L'A';  // = 0x0041
7:	wchar_t lf  = L'\n';  // = 0x000A
8:	
9:	// Zuweisungen von Strings
10:	const char *pText;   // const char-Zeiger
11:	pText = "Dies ist ein String!";

Mehrfach-Zuweisung

Bei der Mehrfach-Zuweisung wird ein Datum mehreren Variablen in einer Anweisung zugewiesen. Die einzelnen Variablen werden mit dem Zuweisungsoperator verkettet und rechts wird der zuzuweisende Ausdruck angegeben. Die Zuweisungen erfolgen in der Reihenfolge von rechts nach links.

1:	// Variablendefinitionen
2:	short sVar1, sVar2;
3:	char cVar;
4:	
5:	// Zuweisungen
6:	sVar1 = sVar2 = 0xFF;   // Ergebnis: sVar2=255, sVar1=255
7:	sVar1 = cVar = 0xFF;    // Ergebnis: cVar=-1, sVar1=-1
8:	cVar = sVar1 = 0xFF;    // Ergebnis: sVar1=255, cVar=-1!

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

Hier folgen in der Offline-Version die Übungen.