switch language to english

Übungen

<< Zurück

Auf dieser Seite sind alle Übungen zusammengestellt, die im Kurs gemacht werden. Ich habe bewusst alles auf eine lange Seite gepackt, so dass Sie alle Übungen auf einmal ausdrucken können.

Übung 1: Einloggen & Unix

  • Loggen Sie sich mit Ihrem URZ Account (Uni-ID) in den gnome Desktop ein.
  • Öffnen Sie ein Terminal (In der Tool Liste unter Zubehör). Falls das Terminal nicht unter Zuberhör zu finden ist, muss man ihn
  • Schauen Sie nach, welche Files es schon gibt.
  • Erzeugen Sie ein neues Verzeichnis cppkurs (z.B.).
  • Wechseln Sie in das Verzeichnis.
  • Erzeugen Sie darin ein Unterverzeichnis v1 und wechseln Sie dort hin.
  • Starten Sie einen Editor, z.B. kate, legen Sie ein neues File an, geben Sie etwas Text ein und speichern Sie das File.
  • Welche Dateien gibt es jetzt im Verzeichnis? Ändern Sie etwas und speichern Sie wieder. Welche Files gibt es jetzt?
  • Wechseln Sie ins Verzeichnis cppkurs und legen Sie dort ein weiteres Unterverzeichnis v2 an.
  • Kopieren Sie die Files in v1 nach v2. Schauen Sie von cppkurs aus nach, ob die Files in v2 angekommen sind.
  • Wechseln Sie nach v2 und schauen Sie sich von hier aus an, welche Files es in v1 gibt. Löschen Sie v1.
  • Gehen Sie in den Editor. Ist das File in v2 korrekt angekommen?

Übung 2: Hallo Welt

  • Erzeugen Sie sich (z.B.) in cppkurs ein Unterverzeichnis uebung2 und wechseln Sie dorthin.
  • Erstellen Sie die Datei hello.cpp wie in der Vorlesung im uebung2 Verzeichnis
  • Bennen Sie den File um in uebung2.cpp
  • Ändern Sie die Begrüßung beliebig ab, Überlegen Sie noch einmal, was jede Zeile macht!
  • Übersetzen Sie das Programm. Wenn Sie Fehler erhalten, arbeiten Sie sie von oben her ab. Lernen Sie, die Meldungen zu verstehen....
  • Binden Sie das Programm und starten Sie es mit ./uebung2 .
  • Spielen Sie nun mit der Ausgabe. Geben Sie mehrere Teile mit std::cout << xxx << yyy <<... aus, erzeugen Sie mehrere Zeilen mit std::endl. Geben Sie auch einmal eine ganze Zahl oder eine Gleitkommazahl (3.141 oder so, Achtung: Man muss einen Punkt benutzen, kein Komma!) aus.
  • Erstellen Sie eine Anfrage nach einer Eingabe. Zunächst nach einem Buchstaben (char), und einer weiteren Anfrage nach der Eingabe von einem Int. Benutzen Sie für die Übergabe der Eingabe an Ihr Programm die std::cin >> x; Funktion.
  • Geben Sie die eingegebenen Werte über die Konsole wieder aus.
Zur Musterlösung

Übung 3a: Datentypen und verschiedene Operatoren

In dieser Übung sollen eine Vielzahl von Operatoren und Datentypen benutzt und ausprobiert werden, einige Operatoren sind natürlich schon wohl bekannt wie "+,-,*,/", wie steht es aber mit den logischen Operatoren "&,|,^,~" oder den Schiebe-Operatoren "<<,>>"?
  • Erzeugen Sie sich ein neues Verzeichnis für diese Übung.
  • Erzeugen Sie einen neue File operatoren.cpp
  • Wie in Übung 2 brauchen wir wieder eine int main() in der wir unsere Operatoren benutzen können
  • Legen Sie für jede Übung eigene Variablen an, und überlegen Sie welchen Datentypen sie am besten verwenden sollten
  • Der sizeof-Operator nimmt einen Datentyp als Argument und liefert als Ergebnis die Größe des Datentyps als Vielfache von char. Nehmen Sie das folgende Programm als Beispiel und modifizieren Sie es, so daß Sie die Größen aller Ihnen aus der Vorlesung bekannten Datentypen erfahren. Diese Größen sind typisch, gelten aber nur für diese Ausführungsumgebung, auf einer anderen aschine können sie sich unter umständen unterscheiden.!
    #include <iostream>
     
    int main() {
      std::cout << "Size of int: " << sizeof(int) << std::endl;
    }
  • Finden Sie heraus, welches die kleinsten und größten Werte für unsigned char sind. Probieren Sie verschiedene Werte für char auf der Konsole auszugebene, was sehen Sie z.B. für unsigned char a = 50; .? Googeln Sie einmal eine ASCII Tabelle und schauen Sie sich verschiedene Werte an. Versuchen Sie den Zahlwert des chars in der Konsole anzuzeigen.
  • Erstellen Sie einen char bitvector = 0b1101; . Geben Sie nun für jede bitposition auf der Konsole aus, ob das Bit gesetzt (1) ist, oder nicht (0). Benutzen Sie für den Vergleich jeweils einen geeigneten bitvector sowie die logischen operatoren. Können Sie für den Vergleich aller Bitpositionen auch eine Variable benutzen, die Sie geschickt initialisieren, und mit den richtigen Operatoren für jeden Vergleich verändern?
  • Funktioniert das auch für int value = 2104; ?. Finden Sie heraus welches das höchste gesetzte bit ist. Wie sieht es denn aus für value = -1; ?.

Zur Musterlösung


Übung 3b: Boolsche Operatoren

  • Erzeugen Sie sich ein neues Verzeichnis für diese Übung.
  • Erzeugen Sie einen neue File booloperatoren.cpp mit einer "int main()" funktion"
  • Gegeben sind folgende logischen Ausdrücke:
    #include <iostream>
     
    int main() {
      bool b1 = true;
      bool b2 = true;
      bool b3 = true;
      bool b4 = false;
     
     
      bool a = ( b1 && !b2) ==  b3; 
      bool b = ( b1 || !b2) == !b3;
      bool c =   b1 && (b2  || b3);
      bool d = ( b1 &&  b4) || (b2 &&  b3)
      bool e = ( b1 || !b2) && (b3 || !b2);
      return 0;
    }
  • 1)Welche der Ausdrücke a-e ergeben true? Überlegen Sie sich zunächst die richtige Antwort, bevor Sie das Programm compilieren und sich die Ergebnisse auf der Konsole ausgeben lassen.
  • 2)Welche Variable muss man ändern damit sich a und b zu true ändern?
  • 3)Ändert sich nun auch etwas an d, oder e?
  • 4)Welche Zeilen ergeben True wenn alle Variable b1-b4 false sind?
  • 5)Welche Zeilen ergeben False wenn alle Variable b1-b4 true sind?

Zur Musterlösung


Übung 3c: Kleines Einmaleins

  • Erzeugen Sie sich ein neues Verzeichnis für diese Übung.
  • Benutzen Sie zunächst eine for (...; ...; ...) {...} Schleife, um die Zahlen von 1 bis 10 auszugeben.
  • Probieren Sie es mit einer do {...} while (...); und mit einer while (...) {} Schleife. Was ist hier am elegantesten / einfachsten / sinnvollsten?
  • Was müssen Sie tun, um die Zahlen untereinander bzw. nebeneinander ausgeben?
  • Nutzen Sie nun eine doppelte Schleife, um das kleine Einmaleins von 1x1 bis 9x9 in Form einer Matrix auszugeben, also
      1   2   3  ...   9
      2   4   6  ...  18
      ...
      9  18      ...  81
    
  • IHR Einmaleins sieht wahrscheinlich noch nicht schön aus, da die 'kleinen' Zahlen weniger Platz brauchen als die 'großen' Zahlen. Wir wollen daher die Zahlen mit genau drei Stellen Breite auszugeben (also __1 bzw. _81). Suchen Sie im Internet, z.B. unter http://www.cplusplus.com, nach einer einfachen Möglichkeit. Ist der Befehl precision richtig? (Tipp: nein, aber der richtige Befehl ist nicht weit...)
  • Führen Sie Konstanten const int NX = ...; const int NY = ...; zu Beginn des Programms ein, so dass die Größe einfach verändert werden kann. Probieren Sie das z.B. mit 4x3 aus, also:
      1   2   3   4
      2   4   6   8
      3   6   9  12
    
  • Was müssen Sie tun, damit die '1' nicht links oben, sondern links unten steht?

Zur Musterlösung


Übung 4a: Kontrollstrukturen if() und else()

Als ersten Einstieg zur Verwendung von Kontrollstrukturen wollen wir Zahlen in strings übersetzen:
  • Erzeugen Sie sich ein neues Verzeichnis und einen file ifelse.cpp mit einer main für diese Übung.
  • Fragen Sie über die Konsole wie in Aufgabe 2 nach einem Integer, und lesen Sie die Zahl mit dem cin operator in ihr Program ein.
  • Fangen Sie mit einer Zahl von 0 - 9 an, und geben Sie die Eingabe als ausgeschriebenen String aus: z.B 1 -> "Eins".
  • Erweitern Sie nun den Zahlenraum auf 0-99, benutzen Sie dafür den Modulo-Operator % um beide Stellengetrennt zu betrachten. Bauen Sie isch daraufhin den ausgabe String zusammen:
     int einerStelle = a%10;
     int zehnerStelle = (a/10)%10;
     
  • Setzen Sie das ganze in eine while(true) - Endlosschleife um beliebig viele Zahlen abzufragen und auszugeben.
  • Programmieren Sie eine Abbruchbedingung (z.B. bei einer negativen Zahl), um die while Schleife wieder zu verlassen.
  • Für schnelle: Erweitern Sie nun den Zahlenraum auf 0-999.

Zur Musterlösung


Übung 4b: Zahlen im Einmaleins (Zahlen Abhaken, Schleifen und Arrays)

Wie viele verschiedene! Produkte kommen im kleinen Einmaleins (1x1 bis 10x10) vor?
  • Wir nutzen dazu ein Feld (array) aus bool Werten an, in dem alle gefundenen Produkte markiert werden.
  • Wie groß muss das Feld sein?
  • Setzen Sie zunächst alle Elemente auf false.
  • Gehen Sie durch alle Produkte und markieren Sie die entsprechenden Elemente mit true.
  • Zählen Sie, wie viele es sind.
  • Achten Sie darauf, dass Sie nicht auf einen verbotenen Index des Arrays zugreifen!
  • ---
  • Für Schnelle: Nutzen Sie nun anstelle von bools einen enum Typ mit den Werten NICHT_GEFUNDEN und GEFUNDEN, um das Programm lesbarer zu machen.
  • Für ganz Schnelle: Die Größe der Matrix soll nun über die Tastatur eingegeben werden. Mit dem Befehl std::cin >> n; unterbricht die Programmausführung und eine Zahl aus der Tastatur wird der Variable n zugewiesen. (Um die unterschiedlichen Einträge zu zählen sollte das bool-Feld später 'dynamisch' angelegt werden. Im Moment können Sie eine maximale Größe definieren und sicherstellen, dass die Eingabe nicht größer als das Maximum ist.)

Zur Musterlösung


Übung 5: Anzahl von Primzahlen (Funktionen & Operatoren)

finden sie zu einer beliebigen Zahl alle kleineren Primzahlen.
  • Erstellen Sie dazu eine Funktion, die die Berechnung ausführt. Diese Funktion soll als Eingabeparameter eine Zahl X vom Typ Integer bekommen und in der main Funktion aufgerufen werden.
  • Der Rückgabe-Wert der Funktion soll die Anzahl der Primzahlen sein, die Kleiner oder gleich dem gegebenen Wert sind. Dafür erstellen Sie zwei geschachtelte Schleifen, die äußere Schleife muss über alle Zahlen von 2 bis X laufen, die Innere dient dazu herauszufinden ob die Zahl der äußeren Schleife eine Primzahl ist. Mit dem Modulo-Operator % können Sie testen, ob eine Zahl durch die Andere ganzzahlig geteilt wird. Brechen Sie die Suche für eine Zahl ab, sobald für Sie ein Teiler gefunden wurde. (TIPP: diese Zahl kommt nicht mehr als Primzahl in Frage)
  • Geben Sie die Anzahl der gefunden Primzahlen über die Konsole aus.
  • Für schnelle: Geben Sie nicht nur die Anzahl sondern alle gefundenen Primzahlen auf der Konsole aus.
  • Zusatz für ganz schnelle:
    1. Speichern Sie die gefundenen Primzahlen in einem File. Gehen Sie dazu auf www.cplusplus.com und suchen Sie nach ofstream::open. Schauen Sie sich die Benutzung anhand der gegebenen Beispiele an. Vergessen Sie nach dem Öffnen des Files nicht, Ihn wieder zu schließen.
    2. Suchen Sie auf www.cplusplus.com nach difftime. Finden Sie heraus, wie man damit die Zeit messen kann, die eine Funktion zur Ausführung benötigt. Messen Sie damit die Zeit, die zur Bestimmung der Anzahl der Primzahlen benötigt wird. Geben Sie das gefundene Ergebnis auf der Konsole aus.
Zur Musterlösung


Übung 6: Sortieren (Schleifen und Arrays)

Sie sollen ein Feld aus N=10 Zahlen aufsteigend sortieren. Dazu gibt es SEHR viele Möglichkeiten. Wir machen es einfach, aber ineffizient:
  • Starten Sie bei der ersten Position des Feldes, merken Sie sich den Wert dort, und suchen Sie das Feld dann bis zum Ende nach kleineren Zahlen durch.
  • Sollten Sie einen kleineren Wert finden, so merken Sie sich den Wert und die Position.
  • Nach Durchsuchen des Feldes tauschen Sie den kleinsten Wert mit dem ersten Wert. Damit ist sicher gestellt, dass die erste Zahl 'richtig' ist.
  • Wiederholen Sie das, indem Sie von der zweiten, dritten, .. Position starten, bis das Feld ganz abgearbeitet ist.
Zum Speichern der Elemente definieren Sie sich z.B. ein Feld number[] = {9,4,4,1,10,...} mit GENAU 10 Einträgen. Definieren Sie sich auch eine Konstante SIZE=10, um den Code lesbarer und wartbarer zu machen.

Zur Musterlösung

Übung 7a: Zeiger und Felder

  • Erzeugen Sie sich einen Integer und lassen sie sich dessen Adresse ausgeben
  • Erzeugen Sie einen Zeiger auf den Integer und lassen Sie Ihn auf den erzeugten Integer zeigen
  • Verändern Sie den Integer und lassen sie sich den Effekt auf den Zeiger anzeigen
  • Erzeugen Sie nun ein Feld auf 10 integer mit new der Größe 10. Vergessen Sie das delete amEende nicht
  • Initialisieren Sie das Feld und erzeugen Sie eine print Funktion, die den Inhalt des Feldes auf der Konsole ausgibt.
  • Geben Sie die Adressen aller Werte des Feldes aus, was fällt Ihnen auf? Starten Sie das Programm mehrmals, ändert sich etwas?
  • Erzeugen Sie Felder von chars und double und geben Sie ebenfalls die Adressen der Werte der Felder aus, woher kommt der Unterschied?
Zur Musterlösung

Übung 7b: Zeiger und Speicherverwaltung

  • Erzeugen Sie eine 2 dimensionale Struktur namens Point, die zwei float Variablen aufnehmen kann: x und y.
  • Erstellen Sie eine Abfrage nach der Anzahl N von Punkten, die erzeugt werden sollen.
  • Schreiben Sie nun eine Funktion createLinearPoints(), die N erhält und dynamisch einen Speicherbereich von N Punkten anlegt. Anschließend soll sie den Speicher mit N Punkten einer Geraden füllen. (ab 0,0)
  • Geben Sie den Zeiger auf das erzeugte Feld als Return-Wert zurück. Achtung: wieso kann man hier kein Array benutzen? Wie war das noch gleich mit den Gültigkeitsbereichen?
  • Schreiben Sie nun eine Funktion, die den Speicherbereich übergeben bekommt und die N erzeugten Werte auf die Konsole ausgibt.
  • An welcher Stelle des Programms muss der Speicher wieder freigegeben werden?
  • Für schnelle: nun soll eine zweite Funktion erstellt werden createQuadraticPoints(), die einen Speicherbereich mit N Punkten einer quadratischen Funktion füllt.
  • Für ganz schnelle: Es muss natürlich nicht immer eine Standardfunktion sein. Fragen Sie entsprechende Parameter über die Konsole ab, um die Funktionswerte der Funktion zu variieren. (z.B. andere Steigung, Y-Achsenabschnitt ...) Die Parameter sollen nun an die Funktion übergeben werden. Dafür Könnte man auch eine neue Struktur LinearParams erzeugen.
Man kann die Ausgabe auch direkt von der Konsole in einen File umleiten. In Linux geht das ganz einfach mit dem ">"-Operator. Das geht so: ./uebung7 > points.dat . Aber vorsicht die Anfrage nach den Punkten landet dann auch im File und nicht auf der Konsole.
Natürlich kann man auch mit Hilfe eines std::ofstream direkt aus dem Programm heraus in einen File schreiben. Die Daten aus einem File kann man anschließend mit dem Programm gnuplot und einem gnuplot script plot.gp zeichnen lassen. Speichern Sie hierfür das Script als File im gleichen Ordner, in dem Sie auch den Datenfile erzeugt haben. Überprüfen Sie ob der Dateiname auch mit dem Filenahme im Script übereinstimmt ("points.dat").
Das Plotscript kann mit folgender Zeile mit Gnuplot ausgeführt werden: gnuplot plot.gp.
Mit z.B. dem Programm gwenview kann man sich die Grafik dann anschauen: gwenview output.png.

Zur Musterlösung

Übung 8: MyVector Klasse

In der Vorlesung haben wir die einfache Klasse MyVector erzeugt, die bisher noch nicht viel kann. Kopieren Sie den Code in die drei Dateien main.cpp, myVector.cpp und myVector.h

Hauptprogramm main.cpp Datei

  #include <iostream>
  #include "myVector.h"
 
  using namespace std;
  //Schnellbinden mit g++ -o myVector main.cpp myVector.cpp
 
  int main()
  {
    MyVector v(5,10);
    MyVector u(8,1);
 
    MyVector w = u+v;
 
    cout << "Vector w is: ";
    w.print();
 
    return 0;
  }

Code der myVector.h Datei

  class MyVector
  {
 
  public:
      MyVector();
      MyVector(int x_, int y_);
 
      MyVector operator+(MyVector other_vector);
 
      void print();
 
  private:
      int x;
      int y;
  };
Der Rückgabewert des überladenen '+' Operators ist hier ein MyVector Klassen-Objekt.

Code der myVector.cpp Datei

  #include <iostream>
  #include "myVector.h"
 
  using namespace std;
 
  void MyVector::print()
  {
    cout << "x(" << x << ") ";
    cout << "y(" << y << ") ";
    cout << endl;
  }
 
  MyVector::MyVector()
    : x(0),y(0)
  {
    cout << "Vector generated: ";
    print();
  }
 
  MyVector::MyVector(int x_, int y_)
  {
    x= x_;
    y= y_;
 
    cout << "Vector generated: ";
    print();
  }
 
  MyVector MyVector::operator+(MyVector other_vector)
  {
    int newX = x + other_vector.x;
    int newY = y + other_vector.y;
 
    MyVector newVec(newX,newY);
 
    return newVec;
 
  }

  • Fügen Sie der MyVector Klasse den Operator '-' hinzu.
  • Fügen Sie der MyVector Klasse den Operator '*' (Skalarprodukt)
  • Fügen Sie der MyVector Klasse den Operator '+=' hinzu. Was ist der wesentliche Unterschied zwischen '+' und '+='?
  • Überprüfen Sie die Ergebnisse jeweils mit der print Funktion
  • Zusatz: erweitern Sie die MyVector Klasse auf 3 Dimensionen, passen Sie die bestehenden Operationen an, und fügen Sie das Kreuzprodukt als operator%() (Modulo) hinzu.
Zur Musterlösung

Übung 9: Spielfeld

In der Vorlesung haben wir ein Stück code erzeugt, in dem man über die Konsole die Richtung und die Anzahl von Schritten die gegangen werden sollen angeben kann. Hieraus soll nun ein kleines Spiel erstellt werden:

Code main.cpp

   #include <iostream>
 
  // g++ -o spiel main.cpp Spielfeld.cpp
  using namespace std;
 
  int main ()
  {
    int anzahl;
    char s;
    bool exit = false;
 
    while (!exit)
    {
      cout << "Wohin willst du gehen? n,s,w,o  - X für Ende. " << endl;
 
      cin>>s;
 
      if(s=='X'){
        exit = true;
      }else{
 
        cout << "Wieviele Schritte?" << endl;
        cin >> anzahl;
 
        if(cin.fail()){         // Falls statt einer Zahl ein Buchstabe eingegeben wurde
                                // gibt cin.fail() true zurück
 
          cout << "ungültige Eingabe - keine Aktion" << endl;
          cin.clear();         // setzt die Eingabe zurück
          cin.ignore(20,'\n'); // Zur Sicherheit: die nächsten 20 Buchstaben bis '\n'
                               // werden gelöscht
        }else{
          cout << "Gehe nach ";
 
          if(s=='n'){
            cout << "Norden" << endl;
          } else if(s=='s'){
            cout << "Süden" << endl;
          } else if(s=='w'){
            cout << "Westen" << endl;
          } else if(s=='o'){
            cout << "Osten" << endl;
          } else{
            cout << "ungültig" << endl;
            continue;
          }
 
          for(int i=0; i< anzahl; i++){
          cout << i << " ";
          }
          cout << endl;
        }
      }
    }
 
    return 0;
  }

Spielfeld.h

 using namespace std;
 
 class Spielfeld{
   public:
 
     struct Position{int x,y;};
 
     Spielfeld(int startX, int startY);
     ~Spielfeld();
 
     void bewegen(char richtung, int anzahl);
     void print();
 
   private:
     char feld[20][20];
     Position pos;
 
 };

Spielfeld.cpp

 #include <iostream>
 
 #include "Spielfeld.h"
 
 using namespace std;
 
 Spielfeld::Spielfeld(int startX, int startY)
 {
   pos.x = startX;
   pos.y = startY;
 
   //hier muss das 2D Spielfeld initialisiert werden
 }
 
 Spielfeld::~Spielfeld()
 {
 }
 
 void Spielfeld::print()
 {
 }
 
 void Spielfeld::bewegen(char richtung, int anzahl)
 {
 }
  • Legen Sie die files Spielfeld.cpp und Spielfeld.h an.
  • Initialisieren Sie das 2-dimensionale Spielfeld mit einem geeigneten char Symbol
  • Implementieren Sie die print() Funktion, die das Spielfeld auf der Konsole als 2-dimmensionales Feld ausgibt, hierbei können Sie z.B. entscheiden, ob zwischen den begehbaren Feldern noch ein Platzhalter eingefügt werden soll, oder nicht.
ACHTUNG: in der Konsole wird von oben nach unten ausgeben. Lassen Sie sich das initialisierte Feld ausgeben.
  • Implementieren Sie die void bewegen(char richtung, int anzahl) Funktion:
  • Überschreiben Sie den Wert eines Felds das überlaufen wird mit einem neuen char: '<','>','v','^' je nach gelaufener Richtung.
  • Merken Sie sich in Position pos immer die aktuelle Position für den nächsten Zug.
  • Das Feld, auf das pos am Ende der Bewegung zeigt, können sie mit einem 'X' markieren.
  • Legen Sie das Spielfeld zyklisch an damit Sie nicht aus den Grenzen des Arrays laufen: sobald der Rand (19 od 0) erreicht ist, springen Sie auf die andere Seite und laufen die restlichen Schritte weiter.
  • Geben Sie nach jeder Bewegung das Spielfeld mit der print Funktion aus, und fragen nach einer neuen Bewegung.
  • Um das Spiel schneller zu Spielen können Sie nun die Schrittzahl zu Beginn mit 1 initialisieren.
  • Zur besseren Steuerung können Sie statt 'n','s','o','w' die Buchstaben 'w','s','a','d' belegen (hoch, runter, links, rechts).
  • Geben Sie die möglichen Eingaben nur einmal zu begin des Spiels aus.
Nun wollen wir das Spielfeld dynamisch erzeugen. Das bedeutet bei Anlegen eines Spielfelds wird zusätzlich die gewünschte Größe angeben. Achten Sie darauf, dass der benötigte Speicher mit new korrekt angelegt und im Destruktor auch wieder freigegeben wird.
  • Das Spielfeld muss sich seine Größe merken. Fügen Sie die entsprechenden Parameter der Klasse hinzu.
  • Ändern Sie in der Datei Spielfeld.h den Typ des Felds auf char ** feld; Dies ist ein Zeiger, der auf eine Anzahl von char Zeigern zeigt. So kann ein 2-dimmensionales Array dynamisch erzeugt werden. der Befehl new char*[sizeX] legt ein char ** mit Größe size an.
  • Nun muss jedem Platz von feld[i] ein Zeiger auf sizeY Elemente übergeben werden: new char[sizeY]
  • ebenso muss in zwei Stufen der Speicher wieder freigegeben werden.
  • Ändern Sie die Parameter in print() und bewegen() so, dass die Funktionen mit dem neuen Feld beliebiger Größe korrekt arbeiten.
Zur Musterlösung

Übung 10: Standard-Container

Hier wollen wir uns nun mit Standard-Containern beschäftigen. Standard-Container bieten eine ziemlich umfassende Mögichkeit Daten zu speichern, zu Manipulieren, zu Sortieren, und einfach im Programm damit umzugehen. Die wichtigsten Container-Klassen sind array, vector und map. Ein paar Beispiele dazu finden sie auch am Ende unserer CodeSnippets. Achtung: um alle Funktionen der Container Klassen zu verwenden benötigen Sie den neuen c++ standard. Diesen können sie mir dem flag c++11 im g++ aktivieren:
// g++ -o container container.cpp -std=c++11 -Wall
In dieser Übung wird es erstmal nur um die ersten beiden gehen:
Gegeben ist ein Array: std::array<char,7> alphabet = {'c','d','e','f','g','a','h'};
  • Erstellen Sie zwei Ergebnis-Vectoren std::vector<std::array<char,3> > combinations, selections;
  • In Combinations: speichern Sie alle möglichen Kombinationen von 3 Buchstaben aus dem alphabet.
  • In Selections: speichern Sie alle möglichen Kombinationen von 3 Buchstaben ohne doppelte Buchstaben.
  • Geben Sie den Inhalt der zwei Vektoren auf der Konsole aus.
  • Messen Sie die Zeit zur Erzeugung von combinations und selections (jeweils) mit Hilfe der std::chrono Bibliothek. Versuchen Sie eine Schnelle Implementierung zu finden, wo könnte man Zeit einsparen?
  • Zusatz: Fragen Sie nun über die Konsole nach der Anzahl von Buchstaben, die Pro Ergebnis gespeichert werden sollen. TIPP: Dafür können Sie keinen vector von arrays benutzen.
Zur Musterlösung

-->
zum Seitenanfang