Du bist hier: Startseite > Entwicklung (C/C++) > C++ Grundlagen > Variablen, Konstanten, Datentypen und Typ umwandlungen

Variablen, Konstanten, Datentypen und Typ umwandlungen

Variablen sind Speicherzellen in die man Werte rein schreiben kann. Eine Variable darf aus Buchstaben (groß und klein), aus Zahlen (0-9) sowie dem Underscore (_) bestehen, sollte aber nicht mit einer Zahl anfangen! Es gibt verschiedene Typen von Variablen. Es sollte darauf geachtet werden, dass der richtige Datentyp verwendet wird! Ein float oder double Wert (Gleitkommazahlen) passen natürlich nicht in eine Integer Variable die für Ganzzahlen gedacht ist. Achte unbedingt darauf, dass du einen richtigen Namen für deine Variablen verwendest!.



Wertebereiche und Speichergrößen von C++ Datentypen:

C++ Datentyp Bit-Variante Kleinster möglicher Wert Größter möglicher Wert Speicherplatzbedarf
bool (Boolean) 0 (false) 1 (true) 8 Bit, 1 Byte
char -128 +127 8 Bit, 1 Byte
unsigned char 0 255 8 Bit, 1 Byte
int 16 -32.768 +32.767 16 Bit, 2 Byte
unsigned int 16 0 65.535 16 Bit, 2 Byte
int 32 -2.147.483.648 +2.147.483.647 32 Bit, 4 Byte
unsigned int 32 0 4.294.967.295 32 Bit, 4 Byte
int 64 -9.223.372.036.854.775.808 +9.223.372.036.854.775.807 64 Bit, 8 Byte
unsigned int 64 0 18.446.744.073.709.551.615 64 Bit, 8 Byte
short -32.768 +32.767 16 Bit, 2 Byte
unsigned short 0 65.535 16 Bit, 2 Byte
long -2.147.483.648 +2.147.483.647 32 Bit, 4 Byte
unsigned long 0 4.294.967.295 32 Bit, 4 Byte
long long -9.223.372.036.854.775.808 +9.223.372.036.854.775.807 64 Bit, 8 Byte
unsigned long long 0 18.446.744.073.709.551.615 64 Bit, 8 Byte
Genauigkeit
float 6 Stellen -3,4E+38 +3,4E+38 32 Bit, 4 Byte
double 15 Stellen -1,7E+308 +1,7E+308 64 Bit, 8 Byte
long double 19 Stellen -1,1E+4932 +1,1E+4932 80 Bit, 10 Byte

Dabei muss noch erwähnt werden, dass C++ den Datenwert für Integer – je nach Betriebssystem (16, 32 und 64 Bit) – in der Speichergröße anpasst. So ist ein Integerwert in der 16 Bit-Variante so groß wie ein short (16 Bit = 2 Byte) und in der 32 und 64 Bit-Variante so groß wie ein Long (32 Bit = 4 Byte).

Im folgendem Beispiel wird gezeigt, wie eine Variable deklariert und definiert wird.

Datei:  Quelldateien/main.cpp
  1. #include <iostream> // std::cout, std::endl, std::cin
  2.  
  3. int main(void)
  4. {
  5. 	int iVariablenName; // deklaration
  6. 	iVariablenName = 100; // definition
  7. 	std::cout << iVariablenName << std::endl; // ausgabe auf dem Bildschirm
  8.  
  9. 	int iVariablenName2 = 101; // deklaration & definition
  10. 	std::cout << iVariablenName2 << std::endl;
  11.  
  12. 	bool bVariable = true;
  13. 	std::cout << bVariable << std::endl; // (true gibt 1 zurück!)
  14.  
  15. 	char cZeichen[4] = "abc"; // Character mit 4 Stellen -1 für das NULL Zeichen am Ende
  16. 	std::cout << cZeichen << std::endl;
  17.  
  18.         std::cin.get();
  19.         return 0;
  20. }

Zuerst wird immer der Datentyp definiert, gefolgt von einem Namen. Dahinter kann muss aber keine definition erfolgen. Da der Compiler sich auskennt mit Variablen, weiß er jetzt ganz genau wieviel Speicherplatz er reservieren muss damit auch die maximalen Werte die der Datentyp im Gepäck hat, auch gespeichert werden können.

Der Datentyp einer Variablen kann auch konvertiert werden in einen andern. Das nennt man "casten" und funktioniert folgendermaßen:

Datei:  Quelldateien/main.cpp
  1. #include <iostream> // std::cout, std::endl, std::cin
  2.  
  3. int main(void)
  4. {
  5. 	float fPi = 3.141592f; // f Zeichnet den Wert als float aus, ohne könnte es auch double sein!
  6. 	int iPi = static_cast<int>(fPi); // casten von float nach int
  7.         // <int> gibt denn Typ an, in denn konvertiert werden soll.
  8.         // (...) gibt die zu konvertierende Variable an.
  9. 	std::cout << iPi << std::endl;
  10.  
  11. 	std::cin.get();
  12. 	return 0;
  13. }

Es gibt noch 2 andere Arten, die aus C übernommen worden sind (veraltet!)

Datei:  Quelldateien/main.cpp
  1. #include <iostream> // std::cout, std::endl, std::cin
  2.  
  3. int main(void)
  4. {
  5. 	float fPi = 3.141592f;
  6.  
  7. 	int iPi = (int)fPi;    //c style cast
  8. 	std::cout << iPi << std::endl;
  9.  
  10.         // oder
  11. 	int iPi2 = int(fPi);    //function style cast 
  12. 	std::cout << iPi2 << std::endl;
  13.  
  14. 	std::cin.get();
  15. 	return 0;
  16. }


Bei Konstanten gilt das gleiche wie bei Variablen mit dem Unterschied, dass Konstanten wärend der Laufzeit nicht mehr geändert werden können. Sie bekommen ihre Wertzuweisung bei der deklaration.

Datei:  Quelldateien/main.cpp
  1. #include <iostream> // std::cout, std::endl, std::cin
  2.  
  3. int main(void)
  4. {
  5.     const int iBirthday = 1983;
  6.     std::cout << iBirthday << std::endl;
  7.  
  8.     std::cin.get();
  9.     return 0;
  10. }

Mit typedef kann ein Alias von jedem Datentyp angelegt werden. Im folgenden Beispiel wird uint als Synonym für unsigned int verwendet.

Datei:  Quelldateien/main.cpp
  1. #include <iostream> // std::cout, std::endl, std::cin
  2.  
  3. typedef unsigned int uint;
  4.  
  5. int main(void)
  6. {
  7.     uint test = 100;
  8.  
  9.     std::cin.get();
  10.     return 0;
  11. }


Der folgende Programmcode liesst die Speicherhöhe direkt aus dem Compiler aus!
Ist eigentlich das gleiche wie die Tabelle oben, allerdings bekommst du nur die Werte für 16, 32 oder 64 Bit Integer angezeigt.

Datei:  Quelldateien/main.cpp
  1. #include <iostream> // std::cout, std::endl, std::cin
  2.  
  3. using namespace std;
  4.  
  5. int main()
  6. {
  7. 	cout << "C++ Datentypen + Speicherbelegung\n\n" << endl;
  8. 	cout << "bool:\t\t" << sizeof(bool) << "Byte\t"<< "Min: " << false << "\t\t"<< "Max: " << true << endl;
  9. 	cout << "char:\t\t" << sizeof(char) << "Byte\t"<< "Min: " << CHAR_MIN << "\t"<< "Max: " << CHAR_MAX << endl;
  10. 	cout << "uchar:\t\t" << sizeof(unsigned char) << "Byte \t"<< "Min:  " << "0" << "\t\t"<< "Max: " << UCHAR_MAX << endl;
  11. 	cout << "int:\t\t" << sizeof(int) << "Byte \t"<< "Min: " << INT_MIN << " "<< "Max: " << INT_MAX << endl;
  12. 	cout << "uint:\t\t" << sizeof(unsigned int) << "Byte \t"<< "Min:  " << "0" << "\t\t"<< "Max: " << UINT_MAX << endl;
  13. 	cout << "short:\t\t" << sizeof(short) << "Byte \t"<< "Min: " << SHRT_MIN << "\t"<< "Max: " << SHRT_MAX << endl;
  14. 	cout << "ushort:\t\t" << sizeof(unsigned short) << "Byte \t"<< "Min:  " << "0" << "\t\t"<< "Max: " << USHRT_MAX << endl;
  15. 	cout << "long:\t\t" << sizeof(long) << "Byte \t"<< "Min: " << LONG_MIN << " "<< "Max: " << LONG_MAX << endl;
  16. 	cout << "ulong:\t\t" << sizeof(unsigned long) << "Byte \t"<< "Min:  " << "0" << "\t\t"<< "Max: " << ULONG_MAX << endl;
  17. 	cout << "long long:\t" << sizeof(long long) << "Byte \t"<< "Min: " << LLONG_MIN << " "<< "Max: " << LLONG_MAX << endl;
  18. 	cout << "ulong long:\t" << sizeof(unsigned long long) << "Byte \t"<< "Min:  " << "0" << "\t\t"<< "Max: " << ULLONG_MAX << endl;
  19. 	cout << "float:\t\t" << sizeof(float) << "Byte \t"<< "Min: " << FLT_MIN << " "<< "Max: " << FLT_MAX << endl;
  20. 	cout << "double:\t\t" << sizeof(double) << "Byte \t" << "Min: " << DBL_MIN << " " << "Max: " << DBL_MAX << endl;
  21. 	cout << "long double:\t" << sizeof(long double) << "Byte \t" << "Min: " << LDBL_MIN << " " << "Max: " << LDBL_MAX << "\n\n" << endl;
  22.  
  23. 	std::cin.get();
  24. 	return 0;
  25. }

Kommentare zu diesem Beitrag

Sie müssen angemeldet sein, um eine Nachricht zu erstellen. Anmelden »