Funktionen in C++ definieren und verwenden

Einführung

In diesem Lab werden Sie sich mit den Funktionen in C++ vertraut machen. Funktionen sind ein Eckpfeiler der Programmierung und ermöglichen es Ihnen, Ihren Code in handhabbare, wiederverwendbare Blöcke zu organisieren. Dieses Lab behandelt eine Vielzahl von funktionsbezogenen Themen, von der Erstellung von Funktionen mit verschiedenen Rückgabetypen bis hin zur Nutzung fortschrittlicher Konzepte wie Rekursion und Funktionsüberladung. Sie werden lernen, wie Sie Funktionen definieren, Parameter per Wert und per Referenz übergeben, Standardparameterwerte festlegen und Funktionsprototypen verstehen. Darüber hinaus werden Sie entdecken, wie Sie mehrere Werte mithilfe von Strukturen zurückgeben können. Am Ende dieses Labs werden Sie über eine solide Grundlage für das Schreiben von modularem, effizientem und gut strukturiertem C++-Code verfügen.

Wir beginnen mit der Untersuchung von Funktionen mit verschiedenen Rückgabetypen, wie Ganzzahlen, Fließkommazahlen, Zeichen und Zeichenketten. Anschließend werden Sie den entscheidenden Unterschied zwischen dem Übergeben von Parametern per Wert und per Referenz lernen und wie Standardparameterwerte Ihrer Funktionen Flexibilität verleihen können. Wir werden auch die Funktionsüberladung behandeln, die es Ihnen ermöglicht, mehrere Funktionen mit demselben Namen, aber unterschiedlichen Parameterlisten zu definieren. Darüber hinaus werden Sie rekursive Funktionen erkunden, ein leistungsstarkes Werkzeug zur Lösung von Problemen durch Selbstaufruf. Sie werden sehen, wie Sie Funktionsprototypen in Header-Dateien verwenden können, um einen besser organisierten Code zu erstellen. Schließlich werden Sie entdecken, wie Sie mehrere Werte aus einer Funktion mithilfe von Strukturen zurückgeben können.

Erstellen von Funktionen mit verschiedenen Rückgabetypen

Funktionen sind ein grundlegendes Konzept in der Programmierung. Sie ermöglichen es Ihnen, große Programme in kleinere, handhabbare Teile zu zerlegen, was Ihren Code einfacher zu schreiben, zu verstehen und zu warten macht. Funktionen können auch Werte zurückgeben, wodurch Daten an den aufrufenden Teil des Programms übermittelt werden können.

Hier ist die grundlegende Syntax einer Funktion in C++:

return_type function_name(parameters) {
    // Function body
    return value;
}

• return_type: Dies gibt den Datentyp des Werts an, den die Funktion zurückgeben wird. Wenn die Funktion keinen Wert zurückgibt, verwenden Sie das Schlüsselwort void.
• function_name: Dies ist der Name, den Sie verwenden, um die Funktion aufzurufen. Wählen Sie einen Namen, der den Zweck der Funktion klar beschreibt.
• parameters: Dies sind die Eingabewerte, die Sie an die Funktion übergeben. Sie sind optional, und Sie können null oder mehrere Parameter haben.
• value: Dies ist der Wert, den die Funktion zurückgibt. Er sollte dem return_type der Funktion entsprechen. Wenn der return_type void ist, lassen Sie die return-Anweisung weg oder verwenden Sie einfach return; ohne Wert.

In diesem Schritt werden Sie lernen, Funktionen zu erstellen, die verschiedene Datentypen zurückgeben. Diese Fähigkeit ist entscheidend für das Erstellen vielseitiger und funktioneller Programme.

Öffnen Sie die WebIDE und erstellen Sie eine neue Datei namens function_types.cpp im Verzeichnis ~/project:

touch ~/project/function_types.cpp

Öffnen Sie die Datei function_types.cpp im Editor und fügen Sie den folgenden Code hinzu:

#include <iostream>
#include <string>

// Function returning an integer
int addNumbers(int a, int b) {
    return a + b;
}

// Function returning a double (floating-point number)
double calculateAverage(double x, double y) {
    return (x + y) / 2.0;
}

// Function returning a character
char getGrade(int score) {
    if (score >= 90) return 'A';
    if (score >= 80) return 'B';
    if (score >= 70) return 'C';
    if (score >= 60) return 'D';
    return 'F';
}

// Function returning a string
std::string getStudentStatus(bool isEnrolled) {
    return isEnrolled? "Active" : "Inactive";
}

int main() {
    // Demonstrating different return types
    int sum = addNumbers(5, 3);
    std::cout << "Sum: " << sum << std::endl;

    double average = calculateAverage(10.5, 20.5);
    std::cout << "Average: " << average << std::endl;

    char grade = getGrade(85);
    std::cout << "Grade: " << grade << std::endl;

    std::string status = getStudentStatus(true);
    std::cout << "Student Status: " << status << std::endl;

    return 0;
}

Kompilieren und führen Sie das Programm aus:

g++ function_types.cpp -o function_types
./function_types

Beispielausgabe:

Sum: 8
Average: 15.5
Grade: B
Student Status: Active

Wichtige Punkte zu Funktionsrückgabetypen:

• Funktionen können verschiedene Datentypen zurückgeben, was dem Code Flexibilität verleiht.
• Der return_type wird vor dem Funktionsnamen angegeben und gibt an, welche Art von Daten die Funktion zurücksendet.
• Die return-Anweisung muss dem deklarierten return_type entsprechen, andernfalls meldet der Compiler einen Fehler.
• void-Funktionen geben keinen Wert zurück, und Sie verwenden return; oder lassen die Rückgabestatement einfach weg, wenn Sie am Ende einer void-Funktion sind.
• Sie können primitive Typen (wie int, double, char), Zeichenketten und sogar benutzerdefinierte Typen zurückgeben.
• Stellen Sie sich Funktionsrückgabetypen als verschiedene Arten von Behältern vor. Genauso wie Sie eine Box, einen Beutel oder einen Korb verwenden würden, um verschiedene Gegenstände zu tragen, verwenden Funktionen verschiedene Rückgabetypen, um verschiedene Arten von Daten zurückzusenden.

Übergabe von Parametern an Funktionen per Wert

In diesem Schritt werden Sie lernen, wie man in C++ Parameter an Funktionen per Wert übergibt. Wenn Sie einen Parameter per Wert übergeben, wird eine Kopie des ursprünglichen Arguments erstellt, und diese Kopie wird innerhalb der Funktion verwendet. Alle Änderungen, die an dem Parameter innerhalb der Funktion vorgenommen werden, wirken sich nicht auf die ursprüngliche Variable außerhalb der Funktion aus.

Öffnen Sie die WebIDE und erstellen Sie eine neue Datei namens pass_by_value.cpp im Verzeichnis ~/project:

touch ~/project/pass_by_value.cpp

Öffnen Sie die Datei pass_by_value.cpp im Editor und fügen Sie den folgenden Code hinzu:

#include <iostream>

// Function that demonstrates pass by value
void modifyValue(int x) {
    // This modification only affects the local copy, not the original variable
    x = x * 2;
    std::cout << "Inside function - Value of x: " << x << std::endl;
}

int main() {
    // Original variable
    int number = 10;

    // Print original value
    std::cout << "Before function call - Original value: " << number << std::endl;

    // Call the function with the original variable
    modifyValue(number);

    // Original variable remains unchanged
    std::cout << "After function call - Original value: " << number << std::endl;

    return 0;
}

Kompilieren und führen Sie das Programm aus:

g++ pass_by_value.cpp -o pass_by_value
./pass_by_value

Beispielausgabe:

Before function call - Original value: 10
Inside function - Value of x: 20
After function call - Original value: 10

Erstellen wir ein weiteres Beispiel, um die Übergabe per Wert noch besser zu veranschaulichen:

touch ~/project/swap_values.cpp

Fügen Sie den folgenden Code in die Datei swap_values.cpp ein:

#include <iostream>
#include <string>

// Function to swap values (will not work as expected with pass by value)
void swapValues(int a, int b) {
    int temp = a;
    a = b;
    b = temp;
    std::cout << "Inside function - a: " << a << ", b: " << b << std::endl;
}

int main() {
    int first = 5;
    int second = 10;

    std::cout << "Before swap - first: " << first << ", second: " << second << std::endl;

    // Call swap function
    swapValues(first, second);

    // Original variables remain unchanged
    std::cout << "After swap - first: " << first << ", second: " << second << std::endl;

    return 0;
}

Kompilieren und führen Sie das zweite Programm aus:

g++ swap_values.cpp -o swap_values
./swap_values

Beispielausgabe:

Before swap - first: 5, second: 10
Inside function - a: 10, b: 5
After swap - first: 5, second: 10

Wichtige Punkte zur Übergabe per Wert:

• Eine Kopie des Arguments wird an die Funktion übergeben, wodurch der ursprüngliche Wert erhalten bleibt.
• Änderungen, die an dem Parameter innerhalb der Funktion vorgenommen werden, wirken sich nicht auf die ursprüngliche Variable außerhalb der Funktion aus.
• Die Übergabe per Wert ist für einfache Datentypen wie int, char, float usw. geeignet, wenn Sie den ursprünglichen Wert nicht ändern müssen.
• Wenn Sie große Objekte per Wert übergeben, kann die Kopie mehr Speicher und Zeit verbrauchen, was es im Vergleich zur Übergabe per Referenz weniger effizient macht.

Sie können sich die Übergabe per Wert wie das Anfertigen einer Fotokopie eines Dokuments vorstellen. Das Original bleibt unverändert, und Sie können die Kopie ändern, ohne das Original zu beeinflussen.

Implementierung der Übergabe per Referenz mit dem &-Operator

In diesem Schritt werden Sie lernen, wie Sie in C++ Parameter an Funktionen per Referenz übergeben, indem Sie den &-Operator verwenden. Die Übergabe per Referenz ermöglicht es Ihnen, der Funktion direkten Zugriff auf die ursprüngliche Variable zu gewähren. Das bedeutet, dass alle Änderungen, die an dem Parameter innerhalb der Funktion vorgenommen werden, direkt die ursprüngliche Variable außerhalb der Funktion modifizieren.

Öffnen Sie die WebIDE und erstellen Sie eine neue Datei namens pass_by_reference.cpp im Verzeichnis ~/project:

touch ~/project/pass_by_reference.cpp

Öffnen Sie die Datei pass_by_reference.cpp im Editor und fügen Sie den folgenden Code hinzu:

#include <iostream>

// Function that demonstrates pass by reference
void swapValues(int& a, int& b) {
    // Directly modify the original variables
    int temp = a;
    a = b;
    b = temp;
}

// Function to modify a value using reference
void incrementValue(int& x) {
    // Directly increases the original variable
    x++;
}

int main() {
    // Swap example
    int first = 5;
    int second = 10;

    std::cout << "Before swap - first: " << first << ", second: " << second << std::endl;

    // Call swap function with references
    swapValues(first, second);

    std::cout << "After swap - first: " << first << ", second: " << second << std::endl;

    // Increment example
    int number = 7;

    std::cout << "Before increment: " << number << std::endl;

    // Call increment function with reference
    incrementValue(number);

    std::cout << "After increment: " << number << std::endl;

    return 0;
}

Kompilieren und führen Sie das Programm aus:

g++ pass_by_reference.cpp -o pass_by_reference
./pass_by_reference

Beispielausgabe:

Before swap - first: 5, second: 10
After swap - first: 10, second: 5
Before increment: 7
After increment: 8

Erstellen wir ein weiteres Beispiel, um die Stärke der Übergabe per Referenz zu demonstrieren:

touch ~/project/string_reference.cpp

Fügen Sie den folgenden Code in die Datei string_reference.cpp ein:

#include <iostream>
#include <string>

// Function to modify a string using reference
void appendText(std::string& text) {
    text += " - Modified";
}

int main() {
    std::string message = "Hello, World!";

    std::cout << "Original message: " << message << std::endl;

    // Modify string directly using reference
    appendText(message);

    std::cout << "Modified message: " << message << std::endl;

    return 0;
}

Kompilieren und führen Sie das zweite Programm aus:

g++ string_reference.cpp -o string_reference
./string_reference

Beispielausgabe:

Original message: Hello, World!
Modified message: Hello, World! - Modified

Wichtige Punkte zur Übergabe per Referenz:

• Verwenden Sie & hinter dem Typ, um einen Referenzparameter zu erstellen (z.B. int& a).
• Modifiziert direkt die ursprüngliche Variable, im Gegensatz zur Übergabe per Wert, die eine Kopie verwendet.
• Vermeidet den Aufwand des Kopierens großer Objekte, was es für komplexe Datentypen effizienter macht.
• Nützlich, wenn Sie den ursprünglichen Wert ändern müssen oder mit komplexen Datentypen arbeiten möchten, ohne sie zu kopieren.

Sie können sich die Übergabe per Referenz wie das Übergeben eines Originals anstelle einer Fotokopie vorstellen. Alle Änderungen, die der Empfänger vornimmt, wirken sich direkt auf das Original aus.

Festlegen von Standardwerten für Funktionsparameter

In diesem Schritt werden Sie lernen, wie Sie in C++ Standardwerte für Funktionsparameter festlegen. Standardparameter ermöglichen es Ihnen, Funktionsargumenten Standardwerte zuzuweisen, wodurch Ihre Funktionen vielseitiger und einfacher zu verwenden werden. Wenn ein Aufrufer einen Parameter mit einem Standardwert weglässt, wird automatisch der Standardwert verwendet.

Öffnen Sie die WebIDE und erstellen Sie eine neue Datei namens default_parameters.cpp im Verzeichnis ~/project:

touch ~/project/default_parameters.cpp

Öffnen Sie die Datei default_parameters.cpp im Editor und fügen Sie den folgenden Code hinzu:

#include <iostream>
#include <string>

// Function with default parameters
void greetUser(std::string name = "Guest", int age = 0) {
    std::cout << "Hello, " << name << "!" << std::endl;

    if (age > 0) {
        std::cout << "You are " << age << " years old." << std::endl;
    }
}

// Another example with default parameters for calculation
double calculateArea(double length = 1.0, double width = 1.0) {
    return length * width;
}

int main() {
    // Call function with no arguments (uses default values)
    greetUser();

    // Call function with partial arguments
    greetUser("Alice");

    // Call function with all arguments
    greetUser("Bob", 25);

    // Demonstrate area calculation with default parameters
    std::cout << "\nArea calculations:" << std::endl;

    // Default area (1x1)
    std::cout << "Default area: " << calculateArea() << std::endl;

    // Area with one parameter
    std::cout << "Area with length 5: " << calculateArea(5.0) << std::endl;

    // Area with both parameters
    std::cout << "Area with length 5 and width 3: " << calculateArea(5.0, 3.0) << std::endl;

    return 0;
}

Kompilieren und führen Sie das Programm aus:

g++ default_parameters.cpp -o default_parameters
./default_parameters

Beispielausgabe:

Hello, Guest!
Hello, Alice!
Hello, Bob!
You are 25 years old.

Area calculations:
Default area: 1
Area with length 5: 5
Area with length 5 and width 3: 15

Wichtige Punkte zu Standardparametern:

• Standardwerte werden in der Funktionsdeklaration direkt hinter dem Parametertyp angegeben (z.B. int age = 0).
• Parameter mit Standardwerten müssen am Ende der Parameterliste stehen. Sie können keine Nicht-Standardparameter nach Standardparametern haben.
• Sie können die Funktion mit weniger Argumenten aufrufen, und die fehlenden Argumente verwenden ihre Standardwerte.
• Standardwerte bieten Flexibilität und reduzieren die Notwendigkeit mehrerer Funktionsüberladungen, die dasselbe tun, aber mit leicht unterschiedlichen Eingaben.

Erstellen wir ein weiteres Beispiel, um komplexere Standardparameter zu demonstrieren:

touch ~/project/student_info.cpp

Fügen Sie den folgenden Code in die Datei student_info.cpp ein:

#include <iostream>
#include <string>

// Function with multiple default parameters
void printStudentInfo(
    std::string name = "Unknown",
    int age = 0,
    std::string grade = "N/A",
    bool isEnrolled = false
) {
    std::cout << "Name: " << name << std::endl;
    std::cout << "Age: " << age << std::endl;
    std::cout << "Grade: " << grade << std::endl;
    std::cout << "Enrollment Status: " << (isEnrolled? "Enrolled" : "Not Enrolled") << std::endl;
}

int main() {
    // Different ways to call the function
    printStudentInfo();  // All defaults
    std::cout << "\n";
    printStudentInfo("John");  // Only name
    std::cout << "\n";
    printStudentInfo("Alice", 20);  // Name and age
    std::cout << "\n";
    printStudentInfo("Bob", 22, "A", true);  // All parameters

    return 0;
}

Kompilieren und führen Sie das zweite Programm aus:

g++ student_info.cpp -o student_info
./student_info

Beispielausgabe:

Name: Unknown
Age: 0
Grade: N/A
Enrollment Status: Not Enrolled

Name: John
Age: 0
Grade: N/A
Enrollment Status: Not Enrolled

Name: Alice
Age: 20
Grade: N/A
Enrollment Status: Not Enrolled

Name: Bob
Age: 22
Grade: A
Enrollment Status: Enrolled

Sie können sich Standardparameter wie ein Buffet vorstellen, bei dem Sie sich alle Gerichte nehmen können oder nur einige, wobei einige Gerichte automatisch ergänzt werden, wenn Sie sie nicht angeben.

Erstellen von Funktionsüberladungen mit verschiedenen Parametern

In diesem Schritt werden Sie sich mit der Funktionsüberladung in C++ vertraut machen. Dies ist ein Feature, das es Ihnen ermöglicht, mehrere Funktionen mit demselben Namen zu erstellen, solange sie unterschiedliche Parameterlisten haben (entweder in der Anzahl der Parameter oder in den Typen der Parameter). Dieses Feature macht Ihren Code flexibler und lesbarer, indem es Ihnen ermöglicht, ähnliche Operationen auf verschiedene Datentypen oder mit einer variierenden Anzahl von Eingaben unter Verwendung desselben Funktionsnamens auszuführen.

Öffnen Sie die WebIDE und erstellen Sie eine neue Datei namens function_overloads.cpp im Verzeichnis ~/project:

touch ~/project/function_overloads.cpp

Öffnen Sie die Datei function_overloads.cpp im Editor und fügen Sie den folgenden Code hinzu:

#include <iostream>
#include <string>

// Function overloads for adding different types of numbers
int add(int a, int b) {
    std::cout << "Adding two integers" << std::endl;
    return a + b;
}

double add(double a, double b) {
    std::cout << "Adding two doubles" << std::endl;
    return a + b;
}

// Function overloads with different number of parameters
int add(int a, int b, int c) {
    std::cout << "Adding three integers" << std::endl;
    return a + b + c;
}

// Function overload with different parameter types
std::string add(std::string a, std::string b) {
    std::cout << "Concatenating strings" << std::endl;
    return a + b;
}

int main() {
    // Calling different overloaded functions
    std::cout << "Integer addition: " << add(5, 3) << std::endl;
    std::cout << "Double addition: " << add(5.5, 3.7) << std::endl;
    std::cout << "Three integer addition: " << add(1, 2, 3) << std::endl;
    std::cout << "String concatenation: " << add("Hello, ", "World!") << std::endl;

    return 0;
}

Kompilieren und führen Sie das Programm aus:

g++ function_overloads.cpp -o function_overloads
./function_overloads

Beispielausgabe:

Adding two integers
Integer addition: 8
Adding two doubles
Double addition: 9.2
Adding three integers
Three integer addition: 6
Concatenating strings
String concatenation: Hello, World!

Erstellen wir ein weiteres Beispiel, um weitere Funktionsüberladungen zu demonstrieren:

touch ~/project/overloading_examples.cpp

Fügen Sie den folgenden Code in die Datei overloading_examples.cpp ein:

#include <iostream>
#include <string>

// Overloaded print functions
void print(int value) {
    std::cout << "Printing integer: " << value << std::endl;
}

void print(double value) {
    std::cout << "Printing double: " << value << std::endl;
}

void print(std::string value) {
    std::cout << "Printing string: " << value << std::endl;
}

// Overloaded calculate function
int calculate(int a, int b) {
    return a + b;
}

double calculate(double a, double b) {
    return a * b;
}

int main() {
    // Demonstrating function overloading
    print(42);
    print(3.14);
    print("Hello, Overloading!");

    std::cout << "Integer calculation: " << calculate(5, 3) << std::endl;
    std::cout << "Double calculation: " << calculate(5.5, 3.2) << std::endl;

    return 0;
}

Kompilieren und führen Sie das zweite Programm aus:

g++ overloading_examples.cpp -o overloading_examples
./overloading_examples

Beispielausgabe:

Printing integer: 42
Printing double: 3.14
Printing string: Hello, Overloading!
Integer calculation: 8
Double calculation: 17.6

Wichtige Punkte zur Funktionsüberladung:

• Funktionen können denselben Namen haben, solange sie unterschiedliche Parameterlisten haben (unterschiedliche Typen oder unterschiedliche Anzahlen von Parametern).
• Der C++-Compiler entscheidet, welche überladene Funktion aufgerufen wird, basierend auf den Typen und der Anzahl der Argumente, die während des Funktionsaufrufs angegeben werden.
• Die Funktionsüberladung führt zu einem lesbareren und intuitiveren Code, da Sie Namen für ähnliche Aktionen wiederverwenden können.
• Sie können Funktionen nicht überladen, wenn sie sich nur in ihren Rückgabetypen unterscheiden. Die Parameter müssen unterschiedlich sein, damit die Überladung korrekt funktioniert.

Sie können sich die Funktionsüberladung wie eine universelle Fernbedienung vorstellen, die mit verschiedenen Geräten funktioniert. Der gleiche Knopf (Funktionsname) führt unterschiedliche Aktionen aus, abhängig vom Kontext (den Argumenten, die Sie angeben).

Schreiben von rekursiven Funktionen zur Fakultätsberechnung

In diesem Schritt werden Sie sich mit rekursiven Funktionen vertraut machen, indem Sie ein Programm zur Fakultätsberechnung implementieren. Rekursion ist eine Programmiersprachentechnik, bei der eine Funktion sich selbst aufruft, um ein Problem zu lösen. Um unendliche Schleifen zu vermeiden, müssen rekursive Funktionen einen Basisfall haben, in dem sie den rekursiven Aufruf beenden, sowie einen rekursiven Fall, in dem sie sich selbst weiterhin aufrufen, um sich dem Basisfall zu nähern.

Öffnen Sie die WebIDE und erstellen Sie eine neue Datei namens factorial_recursive.cpp im Verzeichnis ~/project:

touch ~/project/factorial_recursive.cpp

Öffnen Sie die Datei factorial_recursive.cpp im Editor und fügen Sie den folgenden Code hinzu:

#include <iostream>

// Recursive function to calculate factorial
unsigned long long calculateFactorial(int n) {
    // Base case: factorial of 0 or 1 is 1
    if (n == 0 || n == 1) {
        return 1;
    }

    // Recursive case: n! = n * (n-1)!
    return n * calculateFactorial(n - 1);
}

int main() {
    // Calculate factorial for different numbers
    int numbers[] = {0, 1, 5, 7, 10};

    for (int num : numbers) {
        unsigned long long result = calculateFactorial(num);
        std::cout << "Factorial of " << num << " is: " << result << std::endl;
    }

    return 0;
}

Kompilieren und führen Sie das Programm aus:

g++ factorial_recursive.cpp -o factorial_recursive
./factorial_recursive

Beispielausgabe:

Factorial of 0 is: 1
Factorial of 1 is: 1
Factorial of 5 is: 120
Factorial of 7 is: 5040
Factorial of 10 is: 3628800

Erstellen wir ein weiteres Beispiel mit einer detaillierteren rekursiven Funktion:

touch ~/project/factorial_steps.cpp

Fügen Sie den folgenden Code in die Datei factorial_steps.cpp ein:

#include <iostream>

// Recursive function with step-by-step output
unsigned long long calculateFactorialWithSteps(int n, int depth = 0) {
    // Add indentation for visualization
    std::string indent(depth * 2, ' ');

    // Base case: factorial of 0 or 1 is 1
    if (n == 0 || n == 1) {
        std::cout << indent << "Base case: factorial(" << n << ") = 1" << std::endl;
        return 1;
    }

    // Recursive case with visualization
    std::cout << indent << "Calculating factorial(" << n << ")" << std::endl;

    // Recursive call
    unsigned long long subResult = calculateFactorialWithSteps(n - 1, depth + 1);

    // Combine results
    unsigned long long result = n * subResult;

    std::cout << indent << "factorial(" << n << ") = "
              << n << " * factorial(" << n-1 << ") = "
              << result << std::endl;

    return result;
}

int main() {
    int number = 5;

    std::cout << "Factorial calculation steps for " << number << ":" << std::endl;
    unsigned long long result = calculateFactorialWithSteps(number);

    std::cout << "\nFinal result: " << number << "! = " << result << std::endl;

    return 0;
}

Kompilieren und führen Sie das zweite Programm aus:

g++ factorial_steps.cpp -o factorial_steps
./factorial_steps

Beispielausgabe:

Factorial calculation steps for 5:
Calculating factorial(5)
  Calculating factorial(4)
    Calculating factorial(3)
      Calculating factorial(2)
        Calculating factorial(1)
        Base case: factorial(1) = 1
      factorial(2) = 2 * factorial(1) = 2
    factorial(3) = 3 * factorial(2) = 6
  factorial(4) = 4 * factorial(3) = 24
factorial(5) = 5 * factorial(4) = 120

Final result: 5! = 120

Wichtige Punkte zu rekursiven Funktionen:

• Rekursive Funktionen rufen sich selbst auf: Eine Funktion ruft sich selbst auf, um kleinere Teilprobleme desselben Typs zu lösen.
• Basisfall: Eine rekursive Funktion muss einen Basisfall haben, eine Bedingung, die die rekursiven Aufrufe beendet. Ohne einen Basisfall wird die Funktion sich unendlich oft selbst aufrufen, was zu einem Stack-Überlauf-Fehler führt.
• Rekursiver Fall: Der rekursive Fall ist der Teil, in dem die Funktion sich selbst aufruft, um sich dem Basisfall zu nähern.
• Problemzerlegung: Rekursion zerlegt ein komplexes Problem in kleinere, einfachere Teilprobleme, was es leichter zu bewältigen macht.
• Stack-Nutzung: Jeder rekursive Aufruf beansprucht Speicherplatz auf dem Aufrufstack des Programms. Tiefe Rekursion kann zu einem Stack-Überlauf führen, also seien Sie sich der Grenzen des Aufrufstacks bewusst.
• Eignung für Probleme: Rekursion eignet sich besonders gut für Probleme, die sich natürlich in kleineren, ähnlichen Teilproblemen definieren lassen, wie z. B. Baumdurchläufe, Divide-and-Conquer-Algorithmen und Fraktalerzeugung.

Sie können sich Rekursion wie eine Reihe von ineinander geschachtelten Matrjoschka-Puppen vorstellen, wobei jede Puppe eine kleinere Version von sich selbst enthält und die innerste Puppe den Basisfall darstellt, der den Schachtelungsprozess beendet.

Verwendung von Funktionsprototypen in Header-Dateien

In diesem Schritt werden Sie sich mit Funktionsprototypen vertraut machen und lernen, wie Sie Header-Dateien verwenden, um Funktionen in C++ zu organisieren und zu deklarieren. Funktionsprototypen deklarieren den Namen, den Rückgabetyp und die Parameter einer Funktion, ohne die Implementierung (den Funktionskörper) bereitzustellen. Durch die Verwendung von Header-Dateien trennen Sie die Schnittstelle einer Funktion (ihre Deklaration) von ihrer Implementierung. Diese Trennung verbessert die Codeorganisation und erleichtert die Wartung und Wiederverwendung von Funktionen in mehreren Teilen Ihres Programms oder in mehreren Programmen.

Öffnen Sie die WebIDE und erstellen Sie drei Dateien im Verzeichnis ~/project:

Zuerst erstellen Sie math_functions.h:

touch ~/project/math_functions.h

Fügen Sie den folgenden Code in math_functions.h ein:

#ifndef MATH_FUNCTIONS_H
#define MATH_FUNCTIONS_H

// Function prototypes for mathematical operations
int add(int a, int b);
int subtract(int a, int b);
int multiply(int a, int b);
double divide(double a, double b);

#endif // MATH_FUNCTIONS_H

.h-Dateien werden für Deklarationen verwendet und enthalten Funktionsprototypen und andere Deklarationen, aber keine Implementierungen. Auf diese Weise können Sie Funktionen deklarieren, ohne sie zu implementieren. Die Direktiven #ifndef, #define und #endif werden als Include-Guards (Inklusionsschutz) bezeichnet und verhindern die mehrfache Einbindung der Header-Datei, was zu Fehlern führen kann.

Als Nächstes erstellen Sie math_functions.cpp:

touch ~/project/math_functions.cpp

Fügen Sie den folgenden Code in math_functions.cpp ein:

#include "math_functions.h"

// Function implementations
int add(int a, int b) {
    return a + b;
}

int subtract(int a, int b) {
    return a - b;
}

int multiply(int a, int b) {
    return a * b;
}

double divide(double a, double b) {
    // Check for division by zero
    if (b == 0) {
        return 0;
    }
    return a / b;
}

Diese .cpp-Datei enthält die eigentlichen Implementierungen der Funktionen, die in der Header-Datei deklariert wurden.

Schließlich erstellen Sie main.cpp:

touch ~/project/main.cpp

Fügen Sie den folgenden Code in main.cpp ein:

#include <iostream>
#include "math_functions.h"

int main() {
    // Demonstrate function calls from header file
    int x = 10, y = 5;

    std::cout << "Addition: " << x << " + " << y << " = " << add(x, y) << std::endl;
    std::cout << "Subtraction: " << x << " - " << y << " = " << subtract(x, y) << std::endl;
    std::cout << "Multiplication: " << x << " * " << y << " = " << multiply(x, y) << std::endl;
    std::cout << "Division: " << x << " / " << y << " = " << divide(x, y) << std::endl;

    return 0;
}

Diese main.cpp-Datei bindet die math_functions.h-Header-Datei ein, wodurch die Funktionsprototypen verfügbar werden. Sie kann dann die in math_functions.cpp implementierten Funktionen verwenden.

Kompilieren Sie das Programm unter Verwendung mehrerer Quelldateien:

g++ math_functions.cpp main.cpp -o math_operations
./math_operations

Beispielausgabe:

Addition: 10 + 5 = 15
Subtraction: 10 - 5 = 5
Multiplication: 10 * 5 = 50
Division: 10 / 5 = 2

Erstellen wir ein weiteres Beispiel mit einer komplexeren Header-Datei:

Erstellen Sie calculator.h:

touch ~/project/calculator.h

Fügen Sie den folgenden Code in calculator.h ein:

#ifndef CALCULATOR_H
#define CALCULATOR_H

class Calculator {
public:
    // Function prototypes for calculator operations
    int add(int a, int b);
    int subtract(int a, int b);
    int calculate(int a, int b, char operation);
};

#endif // CALCULATOR_H

Diese Header-Datei deklariert eine Klasse namens Calculator und ihre öffentlichen Methoden.

Erstellen Sie calculator.cpp:

touch ~/project/calculator.cpp

Fügen Sie den folgenden Code in calculator.cpp ein:

#include "calculator.h"

int Calculator::add(int a, int b) {
    return a + b;
}

int Calculator::subtract(int a, int b) {
    return a - b;
}

int Calculator::calculate(int a, int b, char operation) {
    switch (operation) {
        case '+': return add(a, b);
        case '-': return subtract(a, b);
        default: return 0;
    }
}

Diese calculator.cpp-Datei enthält die Implementierungen für die in der calculator.h-Header-Datei deklarierten Methoden.

Erstellen Sie calculator_main.cpp:

touch ~/project/calculator_main.cpp

Fügen Sie den folgenden Code in calculator_main.cpp ein:

#include <iostream>
#include "calculator.h"

int main() {
    Calculator calc;

    std::cout << "Calculator Operations:" << std::endl;
    std::cout << "10 + 5 = " << calc.calculate(10, 5, '+') << std::endl;
    std::cout << "10 - 5 = " << calc.calculate(10, 5, '-') << std::endl;

    return 0;
}

Diese Hauptdatei verwendet die Calculator-Klasse und führt Operationen aus.

Kompilieren Sie das Taschenrechnerprogramm:

g++ calculator.cpp calculator_main.cpp -o calculator
./calculator

Beispielausgabe:

Calculator Operations:
10 + 5 = 15
10 - 5 = 5

Wichtige Punkte zu Funktionsprototypen und Header-Dateien:

• Header-Dateien (.h) deklarieren Funktionsprototypen, Klassen und andere Deklarationen. Sie fungieren als Schnittstelle und geben an, welche Funktionen verfügbar sind.
• Quelldateien (.cpp) implementieren die in den Header-Dateien deklarierten Funktionen. Sie enthalten den Code für die Funktionsweise der Funktionen.
• #ifndef, #define und #endif (Include-Guards) verhindern die mehrfache Einbindung derselben Header-Datei und vermeiden so potenzielle Kompilierungsfehler.
• Die Verwendung von Header-Dateien fördert die Modularität und Wiederverwendbarkeit des Codes.
• Header-Dateien ermöglichen es Ihnen, das "Was" (Deklarationen) vom "Wie" (Implementierungen) zu trennen.
• Sie erleichtern die Codeorganisation und machen ihn leichter zu warten und zu verstehen.

Sie können sich Header-Dateien wie eine Restaurantkarte vorstellen. Die Karte (Header) listet auf, was es zu bestellen gibt, während die Küche (Quelldatei) die eigentlichen Gerichte zubereitet.

Rückgabe mehrerer Werte mit Strukturen

In diesem Schritt werden Sie lernen, wie Sie in C++ Strukturen verwenden, um mehrere Werte aus einer Funktion zurückzugeben. Strukturen sind benutzerdefinierte Datentypen, die es Ihnen ermöglichen, verschiedene Datentypen unter einem einzigen Namen zu gruppieren. Sie eignen sich ideal, um mehrere verwandte Werte aus einer Funktion auf strukturierte und organisierte Weise zurückzugeben.

Öffnen Sie die WebIDE und aktualisieren Sie die Datei student_info.cpp im Verzeichnis ~/project:

Ersetzen Sie den vorhandenen Code durch folgenden:

#include <iostream>
#include <string>

// Define a structure to hold student information
struct StudentResult {
    std::string name;
    int score;
    bool passed;
};

// Function that returns multiple values using a structure
StudentResult evaluateStudent(std::string name, int testScore) {
    StudentResult result;
    result.name = name;
    result.score = testScore;
    result.passed = (testScore >= 60);

    return result;
}

// Function to calculate multiple statistical values
struct MathStats {
    int sum;
    double average;
    int minimum;
    int maximum;
};

MathStats calculateArrayStats(int numbers[], int size) {
    MathStats stats;
    stats.sum = 0;
    stats.minimum = numbers[0];
    stats.maximum = numbers[0];

    for (int i = 0; i < size; i++) {
        stats.sum += numbers[i];

        if (numbers[i] < stats.minimum) {
            stats.minimum = numbers[i];
        }

        if (numbers[i] > stats.maximum) {
            stats.maximum = numbers[i];
        }
    }

    stats.average = static_cast<double>(stats.sum) / size;

    return stats;
}

int main() {
    // Demonstrate student evaluation
    StudentResult student1 = evaluateStudent("Alice", 75);
    StudentResult student2 = evaluateStudent("Bob", 45);

    std::cout << "Student Results:" << std::endl;
    std::cout << student1.name << " - Score: " << student1.score
              << ", Passed: " << (student1.passed? "Yes" : "No") << std::endl;
    std::cout << student2.name << " - Score: " << student2.score
              << ", Passed: " << (student2.passed? "Yes" : "No") << std::endl;

    // Demonstrate array statistics
    int numbers[] = {5, 2, 9, 1, 7};
    int size = sizeof(numbers) / sizeof(numbers[0]);

    MathStats stats = calculateArrayStats(numbers, size);

    std::cout << "\nArray Statistics:" << std::endl;
    std::cout << "Sum: " << stats.sum << std::endl;
    std::cout << "Average: " << stats.average << std::endl;
    std::cout << "Minimum: " << stats.minimum << std::endl;
    std::cout << "Maximum: " << stats.maximum << std::endl;

    return 0;
}

Kompilieren und führen Sie das Programm aus:

g++ student_info.cpp -o student_info
./student_info

Beispielausgabe:

Student Results:
Alice - Score: 75, Passed: Yes
Bob - Score: 45, Passed: No

Array Statistics:
Sum: 24
Average: 4.8
Minimum: 1
Maximum: 9

Wichtige Punkte zu Strukturen und der Rückgabe mehrerer Werte:

• Strukturen gruppieren verwandte Daten: Sie können Variablen unterschiedlicher Typen (z.B. string, int, bool) zu einer einzigen Einheit gruppieren, was nützlich ist, wenn Sie verwandte Informationen haben.
• Rückgabe komplexer Datentypen: Mit Strukturen können Sie komplexe Datentypen aus Funktionen zurückgeben, was es einfach macht, verwandte Datensätze zu verwalten und weiterzugeben.
• Organisierte Rückgabewerte: Das Zurückgeben von Strukturen hilft, mehrere verwandte Rückgabewerte zu organisieren und macht den Code sauberer und wartbarer.
• Klarer Weg zur Übergabe strukturierter Informationen: Strukturen bieten einen klaren, benannten Container für die Rückgabe mehrerer verwandter Werte und verbessern die Lesbarkeit und Verständlichkeit des Codes.

Sie können sich Strukturen wie eine Mehrfachbox für das Mittagessen vorstellen, die verschiedene Arten von Lebensmitteln in separaten Abteilungen aufnehmen kann.

Zusammenfassung

In diesem Lab haben Sie ein umfassendes Verständnis davon erworben, wie man Funktionen in C++ definiert und verwendet. Sie haben gelernt, Funktionen mit verschiedenen Rückgabetypen zu erstellen, Parameter per Wert und per Referenz zu übergeben, Standardparameterwerte festzulegen und Funktionsüberladung zu nutzen. Darüber hinaus haben Sie rekursive Funktionen untersucht, gelernt, wie man Funktionsprototypen in Header-Dateien verwendet, und wie man mehrere Werte mit Strukturen zurückgibt.

Die behandelten Schlüsselkonzepte umfassen:

• Funktionsrückgabetypen: Sie haben gelernt, dass Funktionen verschiedene Datentypen zurückgeben können und dass die return-Anweisung dem deklarierten Rückgabetyp entsprechen muss.
• Übergabe per Wert und Übergabe per Referenz: Sie verstehen den Unterschied zwischen der Übergabe von Parametern per Wert (Kopie erstellen) und per Referenz (Verwendung der ursprünglichen Variable).
• Standardparameter: Sie haben gelernt, wie man Funktionen flexibler macht, indem man Standardwerte für Funktionsparameter zuweist.
• Funktionsüberladung: Sie haben gesehen, wie man mehrere Funktionen mit demselben Namen, aber unterschiedlichen Parameterlisten definiert, was den Code lesbarer und intuitiver macht.
• Rekursive Funktionen: Sie haben die Macht rekursiver Funktionen erforscht, bei denen eine Funktion sich selbst aufruft, um kleinere Teilprobleme zu lösen, sowie die Wichtigkeit von Basisfällen, um unendliche Rekursion zu vermeiden.
• Funktionsprototypen und Header-Dateien: Sie haben gelernt, wie man Header-Dateien verwendet, um Funktionsdeklarationen zu organisieren, was die Modularität und Wiederverwendbarkeit des Codes fördert.
• Rückgabe mehrerer Werte mit Strukturen: Sie haben entdeckt, wie man mehrere verwandte Werte aus einer Funktion mit Strukturen zurückgibt, die einen organisierten Container für Daten bieten.

Durch das Beherrschen dieser Konzepte sind Sie nun gut gerüstet, um modulareren, effizienteren und besser strukturierten C++-Code zu schreiben, und Sie haben eine solide Grundlage für die Erkundung fortgeschrittenerer Programmiersprachentechniken.