Aus StudiWiki

Inhaltsverzeichnis 1 Variablen 2 Konstanten 3 Praeprozessor-Sachen 4 Typen 5 Array 6 Typendefinition 7 Zuweisungen & Operatoren 8 Ablaufsteuerung 9 Pointer und Referenzen 10 Klassen, Objekte 11 Assert 12 Exception-Handling 13 stl-kruscht

[bearbeiten] Variablen

typ name;              // Uninitialisierte Variable
                       // MUSS VOR BENUTZUNG INITIALISIERT (ZUGEWIESEN) WERDEN
typ name = Wert;       // Variable mit Initialisierung

[bearbeiten] Konstanten

const typ NAME = Wert; // Konstante in GROSSBUCHSTABEN
// Dieses Komentar sagt: Nur eine Variable / Konstante pro Zeile!

int x = 5;
const double PI = 3.14158;

[bearbeiten] Praeprozessor-Sachen

#ifndef P
#define P 3.14158
#else
#undef P
#endif

// Alle define-Sachen werden durch den Praeproz. im Code ersetzt!
// in jedem Header-File STEHT Beispielsweise

#ifndef INCLUDED_KNOTENPUNKT_HPP //erste Zeile ueberhaupt.
#define INCLUDED_KNOTENPUNKT_HPP //zweite Zeile
...
#endif //allerletzte Zeile

// dadurch wird verhindert, dass ein Header mehrmals vom Compiler included wird.

[bearbeiten] Typen

char    // einzelnes Zeichen - definiert in '
string  // Zeichenfolge - definiert in "
bool    // true(!=0)-false(0)
int     // 32-bit pos und neg ganze Zahl.
float   // 32-bit Gleitkommazahl (Benutzung von Konstanten: float myFloat = 1.0f)
double  // 64-bit Gleitkommazahl
void    // 42

// es gibt mods wie z.B.
unsigned int  //nur Positive Zahlen, dadurch auch doppelt so hohes 'Last
unsigned char //hat genauso wie "char" nur 1byte, laesst sich aber von 0..255 ansprechen, 
              //statt -128..127

[bearbeiten] Array

int Ding[5][10]; //erzeugt ein 2dim-Array
int *DynDing = new int[10]; // Array dynamisch erzeugt. Wenn groesse zur Laufzeit unbekannt ist.
delete[] DynDing; // So und nur so und immer Speicher wieder freigeben !!!!

[bearbeiten] Typendefinition

typedef unsigned int natural;
natural x = 5;

enum Farben {Rot, Gruen, Gelb, Blau, Pink};
Farben meineFarbe = Rot;

struct meineKomplexe {
  double real;
  double imag; 
};
meineKomplexe K;
K.real = 5.3;
K.imag = 3.5;

[bearbeiten] Zuweisungen & Operatoren

i = i*7;
i = 3^(7-x);
k = i++; // dasselbe wie: i = i + 1; k = i;
k = ++i; // dasselbe wie: k = i; i = i + 1;
// Genau aus den obigen zwei Zeilen sollten man ++ nicht mit Zuweisungen mergen...
i++;
k=i;
// so soll es aussehen!
// -- analog!

i += 4; // wie i = i + 4;
// *=, -=, /= analog!

//Operatoren NUR auf gleichen Typen verwenden und implizite Casts vermeiden

// Boese:
int i = 4 + 1.0; // impliziter c-Cast und ist deshalb des Ludewigs .. aeh.. Teufels.
// Gut:
int i = 4 + static_cast<int>(1.0);

[bearbeiten] Ablaufsteuerung

for (int i = 0; i<10; i++){
  schleifeninhalt;
    }

while (i<10) {
  schleifeninhalt;
  i++ // dasselbe wie: i = i + 1;
    }

if (i>10) {
  Anweisungen;
} else {
  if (i>20) {
    Anweisungen;
  } else {
    Anweisungen;
  }
}

switch (meineFarbe) {
  case Rot:
    Anweisungen;
    break;
  case Gruen:
    Anweisungen;
    break;
  case Blau:
    Anweisungen;
    break;
  default:
    Anweisungen;
}

[bearbeiten] Pointer und Referenzen

// * ist ein Pointer
// & ist eine Referenz

meineKomplexe K;
meineKomplexe *g; // g ist ein Pointer auf den "Record" meineKomplexe
g = &K;           // g wird auf die "Adresse" von K gesetz
// zum Gruebeln (Beschwerden an grottesn@studi...)
g->real = K.imag; // no comment 
*g.real = &K->imag; // identisch zur Zeile darueber

[bearbeiten] Klassen, Objekte

class KlassenName:public Vaterklasse {
public:
  KlassenName{Parameter}; // Konstruktor: wird bei "new" ausgefuehrt;
  ~KlassenName{};         // Destruktor:  wird bei "delete" ausgefuehrt;
  //Einzigen Methode, die KEINEN Rueckgabewert haben.. auch nicht void.
  //Deklaration von public-Variablen und public-Methoden

protected:
  //analog

private:
  //analog
};// <-- DIESER ";" IST DIE HAEUFIGSTE FEHLERQUELLE IM HPP,
  // da der Fehler im CPP gemeldet wird.

// Verwendung von virtual-Methoden:
class a {
public: 
  int get1() { return 1; }
  virtual int get2() { return 1; }
};

class b : public a { // b erbt von a
public:
   int get1() { return 2; } // überschreibt get1 von a
   virtual int get2() { return 2; } // überschreibt get2 von a
};

b bObjekt(); // Ruft Konstruktor von b auf
a *aPointer = bObjekt; // Ein Pointer vom Typ a, der auf ein Objekt vom Typ b zeigt
a->get1(); // gibt 1 zurück !!!!
a->get2(); // gibt 2 zurück !!!!
// ... Nachdenken und Verstehen!  

[bearbeiten] Assert

assert(int expression)
// Evaluates an expression and when the result is FALSE, prints a diagnostic message and aborts the program
// sollte zum pruefen von Preconditions benutzt werden.

[bearbeiten] Exception-Handling

// Example of the try and catch statements
try {
    // Write the file header
    file.Write((LPSTR)&bmfHdr, sizeof(BITMAPFILEHEADER));

    // Write the DIB header and the bits
    file.WriteHuge(lpBI, dwDIBSize);
}

catch (CFileException* e) {
    ::GlobalUnlock((HGLOBAL) hDib);
    throw;
}

::GlobalUnlock((HGLOBAL) hDib);
   return TRUE;

[bearbeiten] stl-kruscht

vector <int> meinVektor;
vector <vector <int> > deinVektor; // SPACE zwischen den > > MUSS hin, weil das sonst als Stream annimmt

Rest kann selbstaendig in der MSDN nachgeschlagen werden.