Kapitel 6
Alle Codedateien dieses Kapitels herunterladen
06_1_1_Montage.cpp
#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
#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
#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
#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
#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
#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
#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
#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;
}