Unfortunately, this is not enough, as the next section shows.

— Peter Norvig

Quelltext mit beliebigem Texteditor schreiben

#include <iostream> 
// ... Deklarationen, Funktionsdefinitionen
int main()
{
  std::cout << "Hallo, Welt!\n"; // ... Anweisungen
}

Edit-Compile-Run-Zyklus (auf Konsole): hallo.cpp speichern > übersetzen > hallo (hallo.exe unter Windows) > ausführen > Ausgabe

make hallo
hallo
Hallo, Welt!

  auto const richtigeAntwort = 42;

anlegen

  int x, y;
  std::string s = "Hallo"; // erfordert #include <string>

Werte zuweisen / ändern

  x = 3;
  y = 2 * x + 1;
  s += ", Welt!";
  ++x;
  y--;

  std::cout << "text";
  std::cout << x << '\n';  // Ausgabe von x, danach Zeilenvorschub

  std::cin >> x; 

Anweisungen wiederholen (Schleife)

  while (x > 0)    // abweisend
  {
    --x;          
  }

  for (int i = 0; i < 10; ++i)  // "Zählschleife" von 0 bis 9
  {
    std::cout << i << "  ";
  }

  for (auto n: {1,4,9,16})  // für jedes Element in Sequenz
  {
    std::cout << n << "  ";
  }

  do               // nicht abweisend
  {
    --x;           // mindestens einmal 
  } while (x > 0); 

wahlweise ausführen (Entscheidung)

  if (x < 5)
  {
    ++x;
  }
  else  // kann wegfallen
  {
    // oder etwas anderes tun
  }

Ausnahme werfen (Anweisungsfolge abbrechen)

  throw objekt;

Ausnahme behandeln

  try
  {
    // ... unsichere Befehle werfen evtl. Ausnahme
  }
  catch (NullBockException& e)
  {
    // tu was dagegen ...
  }

deklarieren

  Ergebnistyp funktionsname(Parameterliste);

definieren (zugleich Deklaration)

  Ergebnistyp funktionsname(Parameterliste)
  {
    // ... Anweisungen
    return ergebniswert;
  }

Parameterliste leer oder Folge Typ parametername durch Komma getrennt

aufrufen

  ergebnis = funktionsname(argumentliste);

Argumentliste: Übereinstimmung in Anzahl und Typ der Wert mit Parameterliste

  Typ feld[anzahl]; // eindimensional: feld[0] ... feld[anzahl-1] 
  Typ matrix[m][n]; // Rechteckschema: m Zeilen, n Spalten

Feldelemente:

  std::vector<int> v =  { 1, 2, 3 };
  for (auto& e : v) e += 10;
  v.push_back(4);

#ifndef MEIN_HEADER_H
#define MEIN_HEADER_H
// ... Abhängigkeiten
// ... globale Konstanten
// ... Klassendefinitionen
// ... Funktionsdeklarationen
#endif // MEIN_HEADER_H

einbinden

#include "meinHeader.h"

class Particle
{ 
  // ... Attribute 
  // ... Konstruktoren
  // ... Methoden
};

  private: 
    double x, y;   // kein Zugriff von außen möglich
  protected:
    double mass;   // für abgeleitete Klasse zugänglich

  public:
    void move(double dx, double dy)
    {
      x += dx; 
      // ...
    }

Direktzugriff auf Attribute / eigene Methoden, bei Eindeutigkeit kann this→x entfallen: x += dx;

Schreibschutz für lesende Methoden (const)

   double distance() const
   {
     return std::sqrt(x*x+y*y);
   }

setzen Anfangswerte der Attribute (kein Rückgabetyp, Funktionsname ist Klassenname)

  Particle (double x, double y, double mass)
  : mass(mass)
  // , ...
  {
    // ...
  }

Instanzen eines vorher vereinbarten Klassentyps, erzeugt durch Konstruktoraufruf

  Particle sun(0, 0, 3.32e5 * Astronomy::MASS_EARTH);

ansprechbar über Variable, reagieren auf "Botschaften" (Methodenaufruf)

  sun.move(10000 * Astronomy::LIGHT_YEAR, 0);

gruppieren Konstanten, Funktionen, Klassen

namespace Astronomy
{
    double const LIGHT_YEAR = 9.461e12; // meter
    double const MASS_EARTH = 5.979e24; // kilograms
}

Basis-/Oberklasse mit virtuellem Destruktor

class Particle
{ 
public:
  virtual ~Particle() {}
  // ...
};

(Unter-)Klassen ableiten

class BlackHole : public Particle
{
  // ... Zusatzattribute
public:
  // ... Konstruktoren
  BlackHole(double x, double y, double mass)
  : Particle(x, y, mass) // Aufruf Konstruktor Basisklasse
  {
    // ...
  }
  // ... abgeleitete / neue Methoden
}

neue Methode hinzufügen oder geerbte Methode überschreiben (muss von Basis als virtual deklariert sein)

  void move(double dx, double dy)
  {
    Particle::move(dx,dy);   // Basis-Methode aufrufen (optional)
    // ...
  }

std::shared::pointer<Particle> ufo = std::make_shared<BlackHole>(0, 0, 1);
ufo->move(0, 1);
 
if (auto hole = std::dynamic_pointer_cast<Blackhole>(ufo)) 
{ 
  hole->collapse();
}

template <typename T>
T twice(T x)
{
  return 2*x;
}

Spezialisierung

template<>
std::string twice(std::string s)
{
  return s+s;
}

Aufruf

  cout << twice(i);
  cout << twice(s);

template <typename T, int N>
class Array
{
  T data[N];
public:
  T& get(int index);
};  

Methodenrumpf in Header / Übersetzungseinheit sichtbar

template <typename T, int N>
T& Array<T, N>::get(int index)
{
  return data[index]; 
}

Instanzierung bei Variablendeklaration

  Array<int, 50> a;
  a.get(3) = 17;