Twitter und Facebook-Anbindung
X
Tweet Follow @twitterapi
!!! Anbindung an twitter und facebook öffnen !!!

Wenn Ihnen mein Online-Buch gefällt,
dann bedanken Sie sich doch mit einer kleinen Spende...

1 Variablen I

1 Variablen I

Eine Variable ist ein Container, welcher eine bestimmte Art an Informationen aufnehmen kann. Sie dienen zum Speichern von Eingaben, Ergebnissen oder Zuständen und man kann mit ihnen auch Rechnen. Manche Variablen können nur ganze Zahlen, andere gebrochene Zahlen und wieder andere nur Buchstaben bzw. Symbole aufnehmen oder gar nur ein logisches ja oder nein. Die Art der Information, welche eine Variable aufnehmen kann, verleiht ihr den Typ. Man spricht also von einem Variablentypen. Variablen mit einem unterschiedlichen Typ, benötigen einen unterschiedlichen Speicherbedarf. Es gibt auch Typen, welche den gleichen Speicherbedarf benötigen, allerdings wird jener dann anders interpretiert. Man muss sich das in etwa wie verschiedene Töpfe und Pfannen vorstellen. Eine kleine Pfanne benutzt man beispielsweise für ein Spiegelei und man braucht nur eine kleine Herdplatte. Ein großer Topf für Nudeln, kann wesentlich mehr aufnehmen und benötigt eine große Herdplatte. Eine sehr große Bratenpfanne nimmt noch mehr auf und braucht deshalb zwei Herdplatten.

Variablentypen und deren Speicherbedarf

So ähnlich ist es auch bei Variablen. Kleine Variablen, welche nur Buchstaben aufnehmen, benötigen nur ein Byte. Variablen für ganze Zahlen benötigen mehr Platz, nämlich vier Byte, wohingegen sehr große Gleitkommazahlen, mit einer hohen Genauigkeit, acht Byte benötigen.

In C++ gibt es viele verschiedene Variablentypen, welche zur Verfügung stehen. Für dieses Kapitel beschränke ich mich auf die einfachsten Typen. Sie werden nach folgendem Schema deklariert und initialisiert:
<VariablenTyp> <NameDerVariable> [= <WertDenSieBekommenSoll>];

Zum Seitenanfang
Zum Inhaltsverzeichnis

1.1 Einfache Variablen

1.1 Einfache Variablen

Die einfachen Variablen werden im s.g. Stack des Arbeitsspeichers gehalten. Der RAM unterteilt sich in zwei Teile, dem Stack (verhältnismäßig sehr klein) und dem Heap (der ganze große Rest). Alle Variablen die im Stack gehalten werden, werden durch das System reserviert und freigegeben. Daraus resultiert, dass man sich nicht um die Speicherverwaltung kümmern muss.

Bevor man anfangen kann zu Kochen, muss man sich einen Topf aus dem Schrank holen und genauso muss man beim Programmieren erst eine Variable zur Verfügung stellen, bevor man etwas in ihr ablegen kann. Dieses Bereitstellen nennt man definieren einer Variable. Bevor man aber mit einer Variable arbeitet, sollte man ihr gleich zu Beginn einen sinnvollen Wert zuweisen. Dies ist wichtig, weil bei der Definition einer Variable, irgendein Speicherbereich zur Verfügung gestellt wird, welcher vorher einem anderen Programm zur Verfügung stand. Ergo können Sie niemals vorher sagen, was an dieser Stelle im RAM steht und somit ist die Variable zu Beginn mit einem scheinbar willkürlichen Wert gefüllt. Sie müssen sich das vorstellen, als wohnten Sie in einer WG mit schlampigen Mitbewohnern, die den Topf in den Schrank stellen, ohne ihn vorher abgewaschen zu haben. Bevor Sie den Topf also benutzen können, müssen Sie sicher stellen, dass er sauber ist, ihn also abwaschen und können dann gleich Wasser einfüllen. Das nennt man Initialisieren einer Variable.

Im folgendem zeige ich wie man sie definiert und gleich initialisiert. Hier mal die Wichtigsten:

Zum Seitenanfang
Zum Inhaltsverzeichnis

1.6 Datentypen in 64 Bit Systemen

1.6 Datentypen in 64 Bit Systemen

In 64 Bit Systemen kommt es vor, dass manche Datentypen, wie z.B. ein Integer oder ein Handle, statt 32 Bit, 64 Bit besitzt. Dies hängt aber nicht alleine vom Betriebssystem ab, sondern auch von der Entwicklungsumgebung bzw. viel mehr vom Compiler. Der vergrößerte Speicherbereich, hängt mit dem größeren Adressraum zusammen, der verwaltet werden muss. Deswegen sind Pointer größer.

Des Weiteren gibt es auch in 32 Bit Systemen s.g. "WideChar" Datentypen, welche dafür benutzt werden, um Unicode oder UTF-16 aufzunehmen (für erweiterten Schriftsatz um z.B. chinesische oder russische Zeichen darzustellen). Gerade in der "WinAPI" findet man häufig Funktionen in drei verschiedenen Ausführungen, wobei eine davon immer auf "A" und die dritte immer auf "W" endet. Der Hintergrund ist, dass die Funktionen mit dem A einen 8 Bit Zeichensatz und die mit W einen 16 Bit Zeichensatz verlangen. Die Funktionen ohne einen zusätzlichen Buchstaben, sind die intelligenten Funktionen und entscheiden, anhand von internen Schaltern (darauf werde ich später noch eingehen), welche der anderen zwei Funktionen tatsächlich benutzt wird.

Zum Seitenanfang
Zum Inhaltsverzeichnis

1.3 Rechnen mit Variablen

1.3 Rechnen mit Variablen

Der Wert von Variablen kann stets überschrieben werden. Zudem kann man Variablen mathematisch verknüpfen und das Ergebnis der Operation einer anderen Variable zuweisen.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
					
int iGeldVonHans	= 10;				// Variable bekommt Wert 10
int iGeldVonPaul	= 100;				// Variable bekommt Wert 100
int iGesamt		= 0;				// Variable bekommt Wert 0

iGeldVonHans		= iGeldVonHans * 2;		// Geld von Hans verdoppeln
iGeldVonPaul		= iGeldVonPaul - 200;		// Paul macht schulden
iGesamt			= iGeldVonHans + iGeldVonPaul;	// Paul und Hans haben
							// zusammen 80 Schulden
iGesamt			+= 1000;			// Oma Schenkt den beiden 1000
							// sie haben jetzt 920
iGesamt			*= 2;				// Der Gesamtbetrag wird beim
							// Glücksspiel verdoppelt
					

Bei der Verknüpfung zweier Werte, mittels mathematischen Operationszeichen, ist der Typ des Ergebnisses vom größten eingegangenen Typs (nicht Wert). Dies sollte man immer im Hinterkopf behalten, denn das sind beliebte Fehlerquellen.

 1
 2
 3
 4
 5
 6
 7
 8
					
int	iZahl1		= 5;
int	iZahl2		= 10;

float	fErgebnis1	= iZahl1 / iZahl2;		// = 0, da int der größte
							// eingegangene Wert war
float	fErgebnis2	= float(iZahl1) / iZahl2;	// = 0.5, da float der
							// größte Wert war
float	fErgebnis3	= 1.0f / 4.0f;			// = 0.25
					

Einer der wichtigsten Operatoren, ist der s.g. Modulo-Operator "%". Mit ihm bekommt man den Divisionsrest. Mit ihm kann man beispielsweise prüfen, ob eine Zahl, durch eine andere teilbar ist. Gerade im Bereich der Verschlüsslung oder dem Ermitteln von Prüfsummen, kommt dieser Operator ständig zum Einsatz. Hier mal ein kleines Beispiel.

 1
 2
 3
					
int iZahl	= 13;
int iRest	= iZahl % 5;	// iRest bekommt den Wert 3,
				// weil 13 / 5 = 2 Rest 3
					
Zum Seitenanfang
Zum Inhaltsverzeichnis

1.2 Typumwandlungen

1.2 Typumwandlungen

Einfache Variablentypen lassen sich mittels Typumwandlungen (cast) ineinander überführen. Dabei ist allerdings zu beachten, dass es einen Verlust geben kann, wenn man eine höherwertige Variable in eine niederwertige umwandelt (z.B. float zu int).

In diesem Unterkapitel werde ich mich auf die einfachste Art der Typumwandlung beschränken. Später sehen Sie dann, welche anderen Möglichkeiten es gibt und was der Unterschied ist.

Variante 1: (<Zieldatentyp>)<Variablenname>|<Wert>

 1
 2
 3
 4
 5
 6
 7
 8
					
float	fGewicht		= (float)548.7354;
int	iAbgerundet		= (int)fGewicht;	// = 548

char	cZeichen		= '5';
int	iEingabe		= (int)cZeichen;	// = 53 (ASCII-Wert)

int	iBreite			= 18;
float	fGenaueBreite		= (float)iBreite;	// = 18.0000000
					

Variante 2: <Zieldatentyp>(<Variablenname>|<Wert>)

 1
 2
					
float	fGewicht		= float(548.7354);
int	iAbgerundet		= int(fGewicht);	// eher selten genutzt
					

Castings werden in der objektorientierten Programmierung eine große Rolle spielen, aber mehr dazu später.

Zum Seitenanfang
Zum Inhaltsverzeichnis

1.4 Wichtige Datentypen im klassischen ANSI C (16 Bit)

1.4 Wichtige Datentypen im klassischen ANSI C (16 Bit)

Typ Größ Zahlenbereich Formatierungszeichen
short 2 Byte -32.768 - 32.767 hi
unsigned short 2 Byte            0 - 65.535 hu
int 2 oder 4Byte i
unsigned int 2 Byte            0 - 65.535 u
long 4 Byte -2.147.483.648 - 2.147.483.647 li
unsigned long 4 Byte                             0 - 4.294.967.295     lu
float 4 Byte 3,4*10-34 - 3,4*1034 f

Zum Seitenanfang
Zum Inhaltsverzeichnis

1.5 Wichtige Datentypen für C++ (32 Bit)

1.5 Wichtige Datentypen für C++ (32 Bit)

Typ Größ Zahlenbereich Formatierungszeichen
bool 1 Byte 0 oder 1 i
char 1 Byte      0 - 255 c
unsigned char 1 Byte -128 - 127 hu
short int 2 Byte -32.768 - 32.767 hi
int 4 Byte -2.147.483.648 - 2.147.483.647 i
unsigned int 4 Byte                             0 - 4.294.967.295    u
long 4 Byte -2.147.483.648 - 2.147.483.647 li
unsigned long 4 Byte                         0 - 4.294.967.295 lu
float 4 Byte 3,4*10-34 - 3,4*1034 f, e oder g
long long int 8 Byte       -9,2 * 1018 - 9,2 * 1018/td> lli
double 8 Byte 1,7*10-308 - 1,7*10308 lf, le, oder lg
long double 10 Byte 3,4*10-4932 - 1,1*104932 lf le oder lg
Zum Seitenanfang
Zum Inhaltsverzeichnis

© Copyright by Thomas Weiß, 2009 - 2012