Link Search Menu Expand Document

Kapitel 6

Alle Codedateien dieses Kapitels herunterladen

06_1_1_Montage.cpp

Datei herunterladen

#include <iostream>

enum class Day { Sunday, Monday, Tuesday, Wednesday,
                 Thursday, Friday, Saturday };
int main()
{
  Day day = Day::Monday;
  if (day == Day::Monday)
  {
    std::cout << "Garfield hasst Montage" << std::endl;
  }
  return 0;
}

06_1_2_Wochentage.cpp

Datei herunterladen

#include <ctime>  // Für den Zugriff auf die aktuelle Zeit
#include <iostream>

enum class Day { Sunday, Monday, Tuesday, Wednesday,
                 Thursday, Friday, Saturday };
int main()
{
  // Das aktuelle Datum abrufen.
  std::time_t now = std::time(0);
  std::tm time;
  localtime_s(&time, &now);
  // Hinweis: Wenn Sie nicht unter Windows programmieren,
  // müssen Sie die obige Zeile austauschen mit:
  // localtime_r(&now, &time);

  // Das Zeitobjekt in einen unserer Enums umwandeln.
  // Da Enums intern als Zahlen abgespeichert werden,
  // kann man von der Zahl in den Enum casten.
  const Day day = static_cast<Day>(time.tm_wday);
  switch (day)
  {
  case Day::Monday:
    std::cout << "Oh je, Montag..." << std::endl;
    break;
  case Day::Tuesday:  // Intentional fall-throughs
  case Day::Wednesday:
  case Day::Thursday:
    std::cout << "Durchhalten!" << std::endl;
    break;
  case Day::Friday:
    std::cout << "Bald ist Wochenende" << std::endl;
    break;
  case Day::Saturday:
  case Day::Sunday:
    std::cout << "Herrlich, Wochenende!" << std::endl;
    break;
  default:
    // Kann nur sein, falls ein Wochentag vergessen wurde
    return 1;
  }
  const Day favouriteDay = Day::Friday;
  if (day == favouriteDay)
  {
    std::cout << "Heute ist der beste Tag" << std::endl;
  }
  return 0;
}

06_2_Struct.cpp

Datei herunterladen

#include <iostream>
#include <vector>
#include <string>

struct Person
{
  std::string firstName;
  std::string lastName;
  int age = -1;
};

Person getOldestPerson(const Person& a, const Person& b)
{
  if (a.age > b.age)
  {
    return a;
  }
  else
  {
    return b;
  }
}

Person getOldestPerson(const std::vector<Person>& persons)
{
  Person oldest;
  for (Person person : persons)
  {
    if (person.age > oldest.age)
    {
      oldest = person;
    }
  }
  return oldest;
}

int main()
{
  Person melanie;
  melanie.firstName = "Melanie";
  melanie.lastName = "Muster";
  melanie.age = 42;
  std::cout << melanie.lastName << ", " << melanie.firstName
    << ". Alter: " << melanie.age << std::endl;

  Person markus;
  markus.firstName = "Markus";
  markus.lastName = "Muster";
  markus.age = 41;
  if (melanie.age > markus.age)
  {
    std::cout << "Melanie ist \204lter" << std::endl;
  }

  // Nutze die Funktion für die Altersbestimmung
  std::cout << "\216lteste Person: "
    << getOldestPerson(melanie, markus).firstName
    << std::endl;
  // Nutze die überladene Funktion mit std::vector
  std::vector<Person> persons = { melanie, markus };
  std::cout << "\216lteste Person: "
    << getOldestPerson(persons).firstName
    << std::endl;
  return 0;
}

06_3_1_Klasse.cpp

Datei herunterladen

#include <iostream>
#include <vector>
#include <string>

class Person
{
 public:
  std::string firstName;
  std::string lastName;
  int age = -1;
};

Person getOldestPerson(const Person& a, const Person& b)
{
  if (a.age > b.age)
  {
    return a;
  }
  else
  {
    return b;
  }
}

Person getOldestPerson(const std::vector<Person>& persons)
{
  Person oldest;
  for (Person person : persons)
  {
    if (person.age > oldest.age)
    {
      oldest = person;
    }
  }
  return oldest;
}

int main()
{
  Person melanie;
  melanie.firstName = "Melanie";
  melanie.lastName = "Muster";
  melanie.age = 42;
  std::cout << melanie.lastName << ", " << melanie.firstName
    << ". Alter: " << melanie.age << std::endl;

  Person markus;
  markus.firstName = "Markus";
  markus.lastName = "Muster";
  markus.age = 41;
  if (melanie.age > markus.age)
  {
    std::cout << "Melanie ist \204lter" << std::endl;
  }

  // Nutze die Funktion für die Altersbestimmung
  std::cout << "\216lteste Person: "
    << getOldestPerson(melanie, markus).firstName
    << std::endl;

  // Nutze die überladene Funktion mit std::vector
  std::vector<Person> persons = { melanie, markus };
  std::cout << "\216lteste Person: "
    << getOldestPerson(persons).firstName
    << std::endl;
  return 0;
}

06_3_2_KlasseMitKonstruktor.cpp

Datei herunterladen

#include <iostream>

class Person
{
 public:
  Person(const std::string& f, const std::string& l, int a)
    : firstName(f), lastName(l), age(a)
  {
  }
  std::string firstName;
  std::string lastName;
  int age = -1;
};

int main()
{
  Person melanie("Melanie", "Muster", 42);
  std::cout << melanie.lastName << "," << melanie.firstName
    << ". Alter: " << melanie.age << std::endl;
  return 0;
}

06_3_3_KlasseMitMehrerenKonstruktoren.cpp

Datei herunterladen

#include <iostream>
#include <vector>
#include <string>

class Person
{
 public:
  Person(const std::string& f, const std::string& l, int a)
    : firstName(f), lastName(l), age(a)
  {
  }
  Person()
  {
    // Wenn Sie mit den Standardwerten zufrieden sind
    // (siehe unten age = -1), könnten Sie den Konstruktor
    // auch leer lassen. Oder Sie schreiben beliebigen
    // anderen Code hinein, wie folgenden:
    std::cout << "Nutze Standardkonstruktor" << std::endl;
  }
  std::string firstName;
  std::string lastName;
  int age = -1;
};

Person getOldestPerson(const std::vector<Person>& persons)
{
  Person oldest;
  for (Person person : persons)
  {
    if (person.age > oldest.age)
    {
      oldest = person;
    }
  }
  return oldest;
}

int main()
{
  Person emptyPerson;
  Person melanie("Melanie", "Muster", 42);
  std::cout << melanie.lastName << "," << melanie.firstName
    << ". Alter: " << melanie.age << std::endl;

  Person markus("Markus", "Muster", 41);
  // Nutze die überladene Funktion mit std::vector
  std::vector<Person> persons = { emptyPerson, melanie, markus };
  std::cout << "\216lteste Person: "
    << getOldestPerson(persons).firstName << std::endl;
  return 0;
}

06_4_1_Hotel.cpp

Datei herunterladen

#include <iostream>
#include <vector>
#include <string>

class Person
{
 public:
  Person(const std::string& f, const std::string& l, int a)
    : firstName(f), lastName(l), age(a)
  {
  }
  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;
  }
  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;
  }
  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())  // analog zu .size() == 0
      {
        output += "  Leer\n";
      }
      output += "-----------------------------\n";
    }
    return output;
  }
  const std::string name;
  std::vector<Room> rooms;
};

int main()
{
  // Auch Listen von komplexeren Objekten können
  // mit {} befüllt werden:
  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);
  hotel.book(Person("Melanie", "Muster", 42), 60);
  hotel.book(Person("Markus", "Muster", 41), 60);
  std::cout << hotel.toString() << std::endl;
  return 0;
}

06_4_2_HotelInteraktiv.cpp

Datei herunterladen

#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;
  }
  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;
  }
  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())  // analog zu .size() == 0
      {
        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)
  {
    std::cout << "Nachname,Vorname,Alter:" << std::endl;
    // String über die Konsole entgegennehmen
    std::string input;
    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
    {
      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;
      }
    }
  }
  return 0;
}