Code-Bibliothek — Capypad · Code Zeile für Zeile lesen

C++ · MittelSnippet

RAII und Ausnahmesicherheit

Resource Acquisition Is Initialization (RAII) ist ein zentrales C++-Konzept. Ressourcen sind an die Lebensdauer von Objekten gebunden; sie werden im Konstruktor angefordert und im Destruktor freigegeben, was Lecks selbst bei Ausnahmen verhindert.

snippet.cpp

cpp

1

2

3

4

5

6

7

8

9

10

11

12

13

14

#include <mutex>
 
std::mutex mtx;
 
void shared_resource_access() {
    // Mutex is locked in constructor
    std::lock_guard<std::mutex> lock(mtx);
    
    // Critical section: performing work
    if (/* something fails */ false) {
        throw std::runtime_error("Error");
    }
    
} // Mutex is released in destructor, even if exception occurs

Memory ManagementBest Practices

C++ · MittelSnippet

Virtuelle Destruktoren bei Vererbung

Wenn man in C++ ein Objekt einer abgeleiteten Klasse über einen Basisklassen-Zeiger löscht, ist das Verhalten undefiniert, sofern die Basisklasse keinen virtuellen Destruktor hat. Das Schlüsselwort 'virtual' garantiert die korrekte Bereinigung der gesamten Hierarchie.

snippet.cpp

cpp

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

class Base {
public:
    virtual ~Base() { /* Cleanup base */ }
};
 
class Derived : public Base {
    int* data;
public:
    Derived() { data = new int[10]; }
    ~Derived() override { delete[] data; }
};
 
void cleanup() {
    Base* ptr = new Derived();
    delete ptr; // Calls Derived destructor because Base destructor is virtual
}

OOPMemory Management

C++ · MittelSnippet

Move-Semantik mit std::move

Die Move-Semantik ermöglicht es, Ressourcen (wie Heap-Speicher) von einem Objekt auf ein anderes zu übertragen, anstatt sie zu kopieren. std::move wandelt ein Objekt in einen R-Value um, sodass der Move-Konstruktor die Daten effizient übernehmen kann.

snippet.cpp

cpp

1

2

3

4

5

6

7

8

9

10

11

12

13

#include <iostream>
#include <vector>
#include <utility>
 
int main() {
    std::vector<int> vec1 = {1, 2, 3, 4, 5};
    // Transfer ownership of resources from vec1 to vec2
    std::vector<int> vec2 = std::move(vec1);
    
    std::cout << "vec2 size: " << vec2.size() << std::endl;
    std::cout << "vec1 size: " << vec1.size() << std::endl; // Likely 0
    return 0;
}

PerformanceMemory Management

C++ · MittelSnippet

Smart Pointer: std::unique_ptr

std::unique_ptr ist ein intelligenter Zeiger, der ein anderes Objekt besitzt und verwaltet und dieses Objekt löscht, sobald der unique_ptr den Gültigkeitsbereich verlässt. Er kann nicht kopiert, sondern nur verschoben werden, was eine strikte Einzelbesitzerschaft garantiert.

snippet.cpp

cpp

1

2

3

4

5

6

7

8

9

10

11

#include <memory>
#include <iostream>
 
void example() {
    // Creating a unique_ptr to an integer
    std::unique_ptr<int> ptr = std::make_unique<int>(42);
    
    if (ptr) {
        std::cout << "Value: " << *ptr << std::endl;
    }
} // ptr is automatically destroyed here, and memory is freed

Memory ManagementBest Practices

C++ · MittelSnippet

Lambda-Ausdrücke und Capturing

Lambdas sind anonyme Funktionen, die inline definiert werden können. Die Capture-Klausel '[]' ermöglicht es dem Lambda, auf Variablen aus dem umgebenden Bereich zuzugreifen, entweder als Kopie oder als Referenz.

snippet.cpp

cpp

1

2

3

4

5

6

7

8

9

10

11

12

13

#include <iostream>
#include <vector>
#include <algorithm>
 
int main() {
    int threshold = 10;
    auto isAbove = [threshold](int val) {
        return val > threshold;
    };
    
    std::cout << std::boolalpha << isAbove(15) << std::endl;
    return 0;
}

FunktionenSyntax

C++ · MittelSnippet

Statische Klassenelemente

Statische Elemente werden von allen Instanzen einer Klasse gemeinsam genutzt. Es gibt nur eine Kopie eines statischen Elements, unabhängig davon, wie viele Objekte erstellt werden.

snippet.cpp

cpp

1

2

3

4

5

6

7

8

class Tracker {
public:
    static int instanceCount;
    Tracker() { instanceCount++; }
};
 
// Definition outside the class
int Tracker::instanceCount = 0;

OOPMemory Management

C++ · MittelSnippet

Template-Spezialisierung

Die Template-Spezialisierung ermöglicht es Ihnen, eine benutzerdefinierte Implementierung eines Templates für einen bestimmten Datentyp zu definieren und so die generische Version zu überschreiben.

snippet.cpp

cpp

1

2

3

4

5

6

7

8

9

10

11

12

13

template <typename T>
class Formatter {
public:
    void print(T val) { /* Default logic */ }
};
 
template <>
class Formatter<bool> {
public:
    void print(bool val) {
        std::cout << (val ? "Yes" : "No");
    }
};

SyntaxPerformance

C++ · MittelSnippet

Operatorüberladung

Die Operatorüberladung ermöglicht es Ihnen, das Verhalten von Standardoperatoren wie + oder - bei der Verwendung mit Ihren eigenen Klassen neu zu definieren.

snippet.cpp

cpp

1

2

3

4

5

6

7

8

9

class Vector2D {
public:
    float x, y;
    Vector2D operator+(const Vector2D& other) const {
        return {x + other.x, y + other.y};
    }
};
 
Vector2D v3 = v1 + v2;

OOPFunktionen