Die Grundtypen von C++

 

• Ganzzahlige Typen
  • char
  • short int
  • int
  • long int
• Fließkomma-Typen
  • float
  • double
  • long double

   

Die Regeln für die Speicherplatzgröße:  

1 = sizeof(char)

<= sizeof(short int)

<= sizeof(int)

<= sizeof(long int)

<= sizeof(double)

<= sizeof(long double)

und

char hat mindestens 8 Bit

short int hat mindestens 16 Bit

long int hat mindestens 32 Bit

Vorzeichen für ganzzahlige Typen

     

unsigned char

unsigned short int

unsigned int

unsigned long int

signed char

signed short int // = short int

signed int // = int

signed long int // = long int

char ist abhängig von der Maschine vorzeichenbehaftet oder nicht

char, signed char und unsigned char sind verschiedene Typen.

Implizite Typumwandlung

   

Die Grundtypen können in Wertzuweisungen und Ausdrücken frei kombiniert werden Information kann verloren gehen.

Beispiel:

    int i = 256 + 255;
    char ch = i;
    int wieviel = ch;

Die implizite Typumwandlung wird durch recht komplexe Regeln beschrieben. Festgelegt werden

• Ausweitung (Integral Promotion): Die Umwandlung von char, short int und Aufzählungselementen nach int.
• Integer-Konvertierung: Die Umwandlung von int in andere ganzzahlige Typen.
• Konvertierungen zwischen float und double.
• Konvertierungen zwischen Fließkommazahlen und ganzen Zahlen.

Angewandt werden diese Regeln z.B. in der Operandenanpassung für arithmetische Ausdrücke.

Beispiel:

    float x = 8.0;
    x *= 1.0 / 2.0    // x == 4.0
    x *= 1.0 / 2      // x == 2.0
    x *= 1 / 2.0      // x == 1.0
    x *= 1 / 2        // x == 0.0

Explizite Typumwandlung

  Zwei mögliche Notationen:  

• C-Cast-Notation: d = (double) a;
• Funktionale Notation: d = double(a);

Die funktionale Notation geht nur bei Typen mit einfachem Namen, also nicht bei:

    char *p = (char *)0777;

Abhilfe durch typedef:

    typedef char* charptr;
    char *p = charptr(0777);

Benutzer-definierte Umwandlung

  Umwandlung mit Konstruktoren  

Ziel: Umwandlung in einen Klassentyp.

Konstruktor-Anwendung ist auch eine explizite Typumwandlung:

    date today = date(17,5,1993);

Mit einstelligen Konstruktoren (bzw. mehrstelligen mit Default-Werten für den zweiten bis letzten Parameter) bekommen wir auch implizite Typumwandlung:  

    class date
    {   int julian;
      public:
        date(int d);
        date(char *datestring);
    }
    void f(date d)
    { date d1 = 17503;
      date d2 = "12.3.1986";
      d1 = 2001;   // date tmp = 2001; d1 = tmp
      f(4000);     // date tmp = 4000; f(tmp)
    }

Umwandlung mit Operatoren  

Ziel: Umwandlung vom Klassentyp in einen anderen Typ.

Form: X::operator T()

definiert eine Umwandlung von X nach T. Diese wird vom Compiler implizit angewandt:

    class tiny
    {    char val;
      public:
         tiny(int i)
         { if (i<0 || i > 63)
           error("Out of Range\n");
           else val = i;
         }
         operator int()
         { return val;}
     };
     tiny t1 = 5;
     tiny t2 = 62;
     int i = t2 - t1;