namespace cpp

C++ lernen, kennen, anwenden

Benutzer-Werkzeuge

Webseiten-Werkzeuge


lernen:minikurs:syntax

Modern C++ in a minute

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

Grundlagen

Programmrahmen

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!

Datentypen

Ganzzahlen int, short, long 0 -123 (dez), 0123 (oktal), 0x1ABC (hex), 2007L (long)
Fließkommazahlen float double -0.5f, 3.1f, 3.1415, -1.609e-19
Einzelzeichen char 'A', '7', '*', '\n' (new line), '\t' (tab),
'\\', '\'', '\"', '\x4A' (ASCII)
Zeichenketten std::string "Hallo"
Wahrheitswerte bool true, false
Platzhalter void "leer", wo kein Typ angegeben werden kann

Konstanten

  const auto richtigeAntwort = 42;

Variablen

anlegen

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

Werte zuweisen / ändern

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

Operationen

arithmetisch x+y x-y x*y x/y x%y (Divisionsrest)
um 1 ändern ++x –x (zuerst), x++ x– (danach)
Zuweisung x = wert
Kurzschrift x += wert (bedeutet x = x + wert)
Vergleiche x<y x⇐y x>=y x>y
…gleich / ungleich x==y x!=y
Logik !a, a && b, a || b
Verneinung UND-Aussage ODER-Aussage
a b !b a && b a || b
false false true false false
false true false false true
true false false true
true true true true

Ausgabe auf den Konsolen-Bildschirm (Standard-Ausgabe)

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

Eingabe von Tastatur (Standard-Eingabe)

  std::cin >> x; 

Steueranweisungen

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 ...
  }

Funktionen

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

Felder mit fester Größe

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

Feldelemente:

matrix[0][0] matrix[0][n-1]
matrix[m-1][0] matrix[m-1][n-1]

Wichtige Bibliotheken

<string> (Zeichenketten)

s.size() Anzahl Zeichen
s[index] Zugriff auf Einzelzeichen, index < s.size()
s == s2 gleicher Inhalt?

<vector> (Felder mit dynamischer Länge)

v.size() Anzahl Elemente
v[index] Zugriff auf Element, index < v.size()
  std::vector<int> v =  { 1, 2, 3 };
  for (auto& e : v) e += 10;
  v.push_back(4);

<cmath> (mathematische Hilfen)

fabs(x) Absolutbetrag
sqrt(x) Quadratwurzel
pow(x, y) x hoch y
exp(x) e hoch x (e = 2.71828…)
log(x) ln x
sin(x) Winkelfunktionen, Umkehr: asin(x)
cos(x)
tan(x) … Umkehr: atan(x), atan2(y, x)

Eigene Header

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

einbinden

#include "meinHeader.h"

Klassen (benutzerdefinierte Datentypen)

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

Attribute

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

Methoden

  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);
   }

Konstruktoren

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

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

Objekte

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);

Namensräume

gruppieren Konstanten, Funktionen, Klassen

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

Vererbung

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)
    // ...
  }

dynamische Polymorphie

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();
}

Schablonen

Funktionen

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);

Klassenschablonen

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;
lernen/minikurs/syntax.txt · Zuletzt geändert: 2016-12-28 19:04 von rrichter