Link Search Menu Expand Document

Kapitel 6

Alle Codedateien dieses Kapitels herunterladen

06_5_1_SchauMirInDieAugen.cpp

Datei herunterladen

/*
 * Lösung für Übung 6.5.1	- Schau mir in die Augen
 *
 * Die Hilfsfunktion colorToString() ist der "Bonus"
 */
#include <iostream>
#include <string>

enum class Color { Brown, Blue, Green, Grey };

std::string colorToString(Color color)
{
  switch (color)
  {
    case Color::Brown:
      return "Braun";
    case Color::Blue:
      return "Blau";
    case Color::Green:
      return "Gr\201n";
    case Color::Grey:
      return "Grau";
    default:
      std::cerr << "Unbekannte Augenfarbe " << static_cast<int>(color) << std::endl;
      return "";
  }
}

class Person
{
public:
  Person(const std::string& f, const std::string& l, int a, Color ec)
    : firstName(f), lastName(l), age(a), eyeColor(ec)
  {
  }
  std::string toString()
  {
    return lastName + ", " + firstName
      + ". Alter: " + std::to_string(age)
      + ". Augenfarbe: " + colorToString(eyeColor);
  }
  std::string firstName;
  std::string lastName;
  int age = -1;
  Color eyeColor;
};

int main()
{
  Person melanie("Melanie", "Muster", 42, Color::Green);
  Person markus("Markus", "Muster", 41, Color::Brown);

  std::cout << melanie.toString() << std::endl;
  std::cout << markus.toString() << std::endl;
  return 0;
}

06_5_2_DasAuto.cpp

Datei herunterladen

/*
 * Lösung für Übung 6.5.2 - Das Auto
 */
#include <iostream>
#include <string>

class Car
{
 public:
  Car(const std::string modelName, int year)
    : modelName(modelName), year(year)
  {
  }
  void drive()
  {
    std::cout << modelName << " f\204hrt" << std::endl;
  }
  void brake()
  {
    std::cout << modelName << " bremst" << std::endl;
  }
  std::string modelName;
  int year;
};

int main()
{
  Car trabbi("Trabant", 1983);
  Car beetle("VW K\204fer", 1955);

  trabbi.drive();
  beetle.drive();
  beetle.brake();
  trabbi.brake();
  return 0;
}

06_5_3_Blockbuster.cpp

Datei herunterladen

/*
 * Lösung für Übung 6.5.3	- Blockbuster
 * 
 * searchKeywordMulti() ist die Bonusfunktion
 */
#include <iostream>
#include <string>
#include <vector>

struct Movie
{
  Movie(const std::string& title, int year, const std::vector<std::string>& keywords)
    : title(title), year(year), keywords(keywords)
  {
  }
  std::string title;
  int year;
  std::vector<std::string> keywords;
};

Movie searchKeyword(const std::vector<Movie>& movies, const std::string& keyword)
{
  for (Movie movie : movies)
  {
    for (std::string movieKeyword : movie.keywords)
    {
      if (movieKeyword == keyword)
      {
        return movie;
      }
    }
  }
  // Den "leeren Film" zurückgeben
  return Movie("", 0, {});
}

std::vector<Movie> searchKeywordMulti(const std::vector<Movie>& movies, const std::string& keyword)
{
  std::vector<Movie> result;
  for (Movie movie : movies)
  {
    for (std::string movieKeyword : movie.keywords)
    {
      if (movieKeyword == keyword)
      {
        result.push_back(movie);
      }
    }
  }
  return result;
}

int main()
{
  std::vector<Movie> movies = {
    Movie("Der Pate", 1972, { "Mafia", "Drogen", "Drama" }),
    Movie("Leon der Profi", 1994, { "Mafia", "Drama", "Rache" }),
    Movie("Zur\201ck in die Zukunft", 1985, { "Zeitreisen", "Kom\224die" }),
    Movie("Forrest Gump", 1994, { "Kom\224die", "Drama", "Melodram" })
  };

  Movie drama = searchKeyword(movies, "Drama");
  std::cout << "Einfache Suche: " << std::endl << "  " << drama.title << std::endl;

  std::vector<Movie> dramas = searchKeywordMulti(movies, "Drama");
  std::cout << "Mehrfachsuche: " << std::endl;
  for (Movie movie : dramas)
  {
    std::cout << "  " << movie.title << std::endl;
  }
  return 0;
}

06_5_4_BeehrenSieUnsBaldWieder.cpp

Datei herunterladen

/*
 * Lösung für Übung 6.5.5 - Beehren Sie uns bald wieder
 * 
 * Dies ist die Erweiterung des Buchbeispiels 06_4_2_HotelInteraktiv.cpp
 * Die Veränderungen sind:
 * - neue Methode checkout() in der Klasse Room
 * - neue Methode checkout() in der Klasse Hotel
 * - Bonus: eine Modusauswahl in main() (siehe Variable bookingMode)
 */
#include <iostream>
#include <vector>
#include <string>

std::vector<std::string> split(const std::string& str)
{
  std::vector<std::string> parts;
  size_t start = 0;
  size_t end = str.find(',');
  while (end != std::string::npos)
  {
    parts.push_back(str.substr(start, end - start));
    start = end + 1;
    end = str.find(',', start);
  }
  parts.push_back(str.substr(start, end));
  return parts;
}

class Person
{
 public:
  Person(const std::string& f, const std::string& l, int a)
    : firstName(f), lastName(l), age(a)
  {
  }
  Person(const std::string& input)
  {
    std::vector<std::string> parts = split(input);
    if (parts.size() == 3)
    {
      lastName = parts.at(0);
      firstName = parts.at(1);
      age = std::stoi(parts.at(2));
    }
  }
  Person()
  {
  }
  std::string toString()
  {
    return lastName + ", " + firstName
      + ". Alter: " + std::to_string(age);
  }
  std::string firstName;
  std::string lastName;
  int age = -1;
};

class Room
{
 public:
  Room(const std::string& n, int c, int p)
    : name(n), capacity(c), pricePerPerson(p)
  {
  }
  bool book(const Person& person, int maxPrice)
  {
    if (pricePerPerson <= maxPrice  // Preis okay
      && persons.size() < capacity)  // Frei
    {
      persons.push_back(person);
      return true;
    }
    // Dieser Raum eignet sich nicht
    return false;
  }
  bool checkout(const Person& person)
  {
    for (int i = 0; i < persons.size(); i++)
    {
      // Wenn alle Eigenschaften gleich sind, nehmen wir an, dass es dieselbe Person ist
      const Person& foundPerson = persons.at(i);
      if (foundPerson.firstName == person.firstName
        && foundPerson.lastName == person.lastName
        && foundPerson.age == person.age)
      {
        persons.erase(persons.begin() + i);
        return true;
      }
    }
    // Die Person wurde nicht in diesem Raum gefunden
    return false;
  }
  const std::string name;
  const int capacity;
  const int pricePerPerson;
  std::vector<Person> persons;
};

class Hotel
{
 public:
  Hotel(const std::string& n, const std::vector<Room>& r)
    : name(n), rooms(r)
  {
  }
  bool book(const Person& person, int maxPrice)
  {
    // Einen freien Raum finden, der dem Preis genügt
    // Wichtig: Per Referenz auf den Raum zugreifen!
    for (Room& room : rooms)
    {
      if (room.book(person, maxPrice))
      {
        return true;
      }
    }
    // Keinen Raum gefunden
    return false;
  }
  bool checkout(const Person& person)
  {
    // Wichtig: Per Referenz auf den Raum zugreifen!
    for (Room& room : rooms)
    {
      if (room.checkout(person))
      {
        return true;
      }
    }
    return false;
  }
  std::string toString()
  {
    std::string output = "Belegung Hotel " + name + ":\n"
      + "=============================\n";
    for (Room room : rooms)
    {
      output += "Raum " + room.name + ":\n";
      for (Person person : room.persons)
      {
        output += person.toString() + "\n";
      }
      if (room.persons.empty())
      {
        output += "  Leer\n";
      }
      output += "-----------------------------\n";
    }
    return output;
  }
  const std::string name;
  std::vector<Room> rooms;
};

int main()
{
  const std::vector<Room> rooms = {
    Room("101", 2, 40),
    Room("102", 2, 50),
    Room("103", 6, 20),
    Room("104", 1, 70)
  };
  Hotel hotel("California", rooms);

  // Interaktive Buchung
  std::cout << "Buchungssystem" << std::endl;
  while (true)
  {
    // String über die Konsole entgegennehmen
    std::string input;
    std::cout << "Buchen (1) oder Auschecken (2) ? ";
    std::getline(std::cin, input);
    const bool bookingMode = (input == "1");

    std::cout << "Nachname,Vorname,Alter:" << std::endl;
    // Neuen String über die Konsole entgegennehmen
    std::getline(std::cin, input);
    // String an den Konstruktor übergeben
    Person person(input);
    if (person.age < 0)
    {
      // Hieran erkennen wir eine "ungültige" Person
      std::cerr << "Eingabefehler!" << std::endl;
    }
    else if (bookingMode)
    {
      // Person soll eingebucht werden
      std::cout << "Maximalpreis: ";
      std::getline(std::cin, input);
      int maxPrice = std::stoi(input);
      if (hotel.book(person, maxPrice))
      {
        std::cout << "Zimmer gefunden!" << std::endl;
        std::cout << hotel.toString();
      }
      else
      {
        std::cout << "Kein Zimmer gefunden!" << std::endl;
      }
    }
    else
    {
      // Person soll ausgecheckt werden
      if (hotel.checkout(person))
      {
        std::cout << "Person wurde ausgecheckt: " << person.toString() << std::endl;
        std::cout << hotel.toString();
      }
      else
      {
        std::cerr << "Konnte Person beim Auschecken nicht finden! Ist sie abgehauen?" << std::endl;
      }
    }
  }
  return 0;
}