Link Search Menu Expand Document

Kapitel 4

Alle Codedateien dieses Kapitels herunterladen

04_1_Beispielfunktionen.cpp

Datei herunterladen

#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

Datei herunterladen

#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

Datei herunterladen

#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

Datei herunterladen

#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

Datei herunterladen

#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

Datei herunterladen

#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

Datei herunterladen

#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

Datei herunterladen

#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

Datei herunterladen

#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;
}