Kapitel 4
Alle Codedateien dieses Kapitels herunterladen
04_1_Beispielfunktionen.cpp
#include <string>
#include <iostream>
void printStart()
{
std::cout << "###############" << std::endl;
std::cout << "Start des Programms" << std::endl;
std::cout << "###############" << std::endl;
// Hier gibt es keine Rückgabe, also auch kein return
}
void printPerson(std::string name, int age)
{
std::cout << name << ", Alter " << age << std::endl;
// Ebenfalls kein return notwendig
}
std::string getOldestPerson(std::string name, int age,
std::string otherName, int otherAge)
{
if (age > otherAge)
{
return name;
}
else
{
return otherName;
}
// Egal welche Bedingung zutrifft, diese Funktion muss
// immer ein return als letzten Befehl haben.
}
int main()
{
printStart();
printPerson("Melanie", 42);
std::string oldest = getOldestPerson("Melanie", 42,
"Markus", 41);
std::cout << oldest << std::endl;
return 0;
}
04_2_1_OhneReferenzen.cpp
#include <iostream>
void subRoutine(int input)
{
std::cout << "Funktion Beginn: " << input << std::endl;
input = 1;
std::cout << "Funktion Ende: " << input << std::endl;
}
int main()
{
int testValue = 0;
std::cout << "Main Beginn: " << testValue << std::endl;
subRoutine(testValue);
std::cout << "Main Ende: " << testValue << std::endl;
return 0;
}
04_2_2_MitReferenzen.cpp
#include <iostream>
void subRoutine(int& input)
{
std::cout << "Funktion Beginn: " << input << std::endl;
input = 1;
std::cout << "Funktion Ende: " << input << std::endl;
}
int main()
{
int testValue = 0;
std::cout << "Main Beginn: " << testValue << std::endl;
subRoutine(testValue);
std::cout << "Main Ende: " << testValue << std::endl;
return 0;
}
04_2_3_ListenSumme.cpp
#include <iostream>
#include <vector>
int main()
{
std::vector<int> list = { 1, 2, 3 };
for (int i = 0; i < list.size(); i++)
{
list.at(i)++;
}
// Liste ist nun { 2, 3, 4 }
for (int& element : list)
{
element++;
}
// Liste ist nun { 3, 4, 5 }
// Ausgabe der Liste:
for (int element : list)
{
std::cout << element << std::endl;
}
return 0;
}
04_2_4_StringsVertauschen.cpp
#include <iostream>
#include <string>
// Diese Funktion vertauscht zwei Strings miteinander
void swap(std::string& a, std::string& b)
{
std::string temp = a;
a = b;
b = temp;
}
int main()
{
std::string first = "Fernando Alonso";
std::string second = "Sebastian Vettel";
swap(first, second);
// Nun ist Vettel Erster und Alonso Zweiter
std::cout << first << std::endl; // "Sebastian Vettel"
std::cout << second << std::endl; // "Fernando Alonso"
return 0;
}
04_3_Buchungssystem.cpp
#include <string>
#include <vector>
#include <iostream>
#include <algorithm>
bool checkTitlesAndDates(
const std::vector<std::string>& eventTitles,
const std::vector<int>& eventDates)
{
if (eventTitles.size() != eventDates.size())
{
// Das muss ein Programmierfehler sein
std::cerr << "Anzahl der Titel und Anzahl der Termine "
<< "muss gleich sein" << std::endl;
return false;
}
// Plausibilität: Hat das Datum exakt acht Stellen?
for (int date : eventDates)
{
if (date < 10000000 || date > 99999999)
{
std::cerr << "Falsches Datum: " << date << std::endl;
return false;
}
}
// Für die Suche muss das Datum sortiert sein
for (int i = 1; i < eventDates.size(); i++)
{
if (eventDates.at(i - 1) > eventDates.at(i))
{
std::cerr << "Termine nicht sortiert" << std::endl;
return false;
}
}
return true;
}
void showHeader(const std::string& text)
{
for (int i = 0; i < text.size(); i++)
{
std::cout << "#";
}
std::cout << std::endl << text << std::endl;
for (int i = 0; i < text.size(); i++)
{
std::cout << "#";
}
std::cout << std::endl;
}
int showSelection(const std::string& question,
const std::vector<std::string>& answers)
{
std::cout << question << std::endl;
for (int i = 0; i < answers.size(); i++)
{
std::cout << i+1 << ": " << answers.at(i) << std::endl;
}
std::cout << "Tippen Sie eine Zahl ein: ";
int selection;
std::cin >> selection;
while (selection <= 0 || selection > answers.size())
{
std::cout << std::endl
<< "Eingabe inkorrekt. Bitte wiederholen: ";
std::cin >> selection;
}
std::cout << "----------------------------" << std::endl;
/*
* Der Nutzer hat eine Zahl zwischen 1 und der Anzahl der
* Elemente eingegeben. Als Programmierer erwarten wir
* aber, dass die Zählung bei 0 beginnt. Daher muss die
* 1 wieder abgezogen werden
*/
return selection - 1;
}
bool findInString(std::string text, std::string query)
{
/*
* Um Groß- und Kleinschreibung beim Suchen zu
* ignorieren, wandeln wir alles in Kleinbuchstaben um
*/
std::transform(text.begin(), text.end(),
text.begin(), tolower);
std::transform(query.begin(), query.end(),
query.begin(), tolower);
/*
* Mit .find() kann man innerhalb eines Strings nach
* einem anderen String suchen. Wenn er nicht gefunden
* wird, ist das Ergebnis std::string::npos (npos steht
* für "no position")
*/
return text.find(query) != std::string::npos;
}
std::vector<int> searchByTitle(
const std::vector<std::string>& titles)
{
std::cout << "Geben Sie ein Suchwort ein: ";
std::string query;
std::cin >> query;
std::vector<int> selections;
for (int i = 0; i < titles.size(); i++)
{
const std::string& title = titles.at(i);
if (findInString(title, query))
{
// Der Suchbegriff wurde im i-ten Titel gefunden
selections.push_back(i);
}
}
return selections;
}
std::vector<int> searchByDate(const std::vector<int>& dates)
{
/*
* Suche alle Termine, die an oder nach dem angegebenen
* Datum stattfinden.
*/
std::cout << "Bitte geben Sie ein Datum ein, ab dem "
<< "nach Veranstaltungen gesucht werden soll."
<< std::endl << "Geben Sie das Datum im Format "
<< "YYYYMMDD ein, also z.B. 20210705: ";
int query;
std::cin >> query;
std::vector<int> selections;
for (int i = 0; i < dates.size(); i++)
{
const int& date = dates.at(i);
if (date >= query)
{
/*
* Dies ist das erste gefundene Datum, was nicht vor
* dem gesuchten Datum liegt. Daher geben wir alle
* übrigen Termine aus. Dafür starten wir eine neue
* for-Schleife beim i-ten Element und gehen von
* dort bis zum Ende der Liste.
*/
for (int j = i; j < dates.size(); j++)
{
selections.push_back(j);
}
// Schleife verlassen, da wir Termine gefunden haben
break;
}
}
return selections;
}
int main()
{
const std::vector<std::string> eventTitles = {
"Rock Concert",
"Jazz Concert",
"Hard-Rock Concert",
"Classical Concert",
"Jazz Concert"
};
// Speichern des Datums als JahrMonatTag, also YYYYMMDD
const std::vector<int> eventDates = {
20220417,
20220822,
20221011,
20221027,
20221203
};
if (!checkTitlesAndDates(eventTitles, eventDates))
{
// Fehlerhafter Datensatz
return 1;
}
showHeader("Willkommen beim digitalen Buchungssystem");
const std::vector<std::string> searchTypes = {
"nach Titel der Veranstaltung",
"nach Termin der Veranstaltung"
};
const int selectedSearch = showSelection(
"Wie wollen Sie suchen?",
searchTypes);
std::vector<int> eventsFound;
switch (selectedSearch) {
case 0:
eventsFound = searchByTitle(eventTitles);
break;
case 1:
eventsFound = searchByDate(eventDates);
break;
default:
std::cerr << "Unerwarteter searchType: "
<< selectedSearch << std::endl;
return 1;
}
if (eventsFound.size() == 0)
{
showHeader("Leider keine Veranstaltung gefunden");
}
else
{
showHeader("Veranstaltungen gefunden:");
std::vector<std::string> selectionTexts;
for (int index : eventsFound)
{
selectionTexts.push_back(eventTitles.at(index)
+ ", am " + std::to_string(eventDates.at(index)));
}
int selected = showSelection(
"Welche Veranstaltung wollen Sie buchen?",
selectionTexts);
showHeader("Sie haben gebucht: "
+ selectionTexts.at(selected));
}
return 0;
}
04_4_1_Fakultaet.cpp
#include <vector>
#include <iostream>
int factorial(int number)
{
if (number == 0)
{
return 1;
}
return number * factorial(number - 1);
}
int factorialIterative(int number)
{
int result = 1;
for (int i = 2; i <= number; i++)
{
result *= i;
}
return result;
}
int main()
{
std::cout << "4! = " << factorial(4) << std::endl;
/*
* Test-Code für die Berechnung der Fakultät
*/
const std::vector<int> tests = { 6, 0, 1 };
const std::vector<int> expected = { 720, 1, 1 };
for (int i = 0; i < tests.size(); i++)
{
if (factorial(tests.at(i)) != expected.at(i))
{
std::cerr << "factorial(" << tests.at(i)
<< ") ist falsch" << std::endl;
return 1;
}
if (factorialIterative(tests.at(i)) != expected.at(i))
{
std::cerr << "factorialIterative(" << tests.at(i)
<< ") ist falsch" << std::endl;
return 1;
}
}
return 0;
}
04_4_2_Modulo.cpp
#include <iostream>
int modulo(int n, int m)
{
if (n < m)
{
return n;
}
else
{
return modulo(n - m, m);
}
}
int main()
{
int a = 4 % 2; // Ergibt 0
std::cout << a << " == " << modulo(4, 2) << std::endl;
a = 5 % 2; // Ergibt 1
std::cout << a << " == " << modulo(5, 2) << std::endl;
a = 6 % 7; // Ergibt 6
std::cout << a << " == " << modulo(6, 7) << std::endl;
a = 123456 % 100; // Ergibt 56
std::cout << a << " == "
<< modulo(123456, 100) << std::endl;
return 0;
}
04_5_Ueberladung.cpp
#include <iostream>
void print(int value)
{
std::cout << "Eine Ganzzahl: " << value << std::endl;
}
void print(double value)
{
std::cout << "Eine Kommazahl: " << value << std::endl;
}
void print(const std::string& value)
{
std::cout << "Eine Zeichenkette: " << value << std::endl;
}
// Auch mehrere Parameter sind möglich
void print(int value, double value2)
{
std::cout << "Eine Ganzzahl: " << value
<< " und eine Kommazahl: " << value2 << std::endl;
}
// Auch eine leere Variante ist möglich
void print()
{
std::cout << "Keine Ausgabe" << std::endl;
}
int main()
{
print(4);
print(4.4);
print("Hallo Welt");
print(1, 2.3);
print();
return 0;
}