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

C++ · ExperteSnippet

Placement New für manuelle Speicherverwaltung

Placement New ermöglicht die Konstruktion eines Objekts an einer vorallokierten Speicheradresse. Dies ist entscheidend für Hochleistungssysteme und benutzerdefinierte Allocatoren, bei denen Heap-Fragmentierung oder Allokations-Overhead vermieden werden müssen.

snippet.cpp

cpp

1

2

3

4

5

char buffer[sizeof(MyClass)];
MyClass* obj = new (buffer) MyClass(42);
 
// Manual cleanup required:
obj->~MyClass();

memoryperformance

C++ · ExperteSnippet

Perfect Forwarding mit std::forward

Perfect Forwarding stellt sicher, dass ein Funktions-Template seine Argumente an eine andere Funktion weitergeben kann, während deren ursprüngliche Value-Category (Lvalue oder Rvalue) erhalten bleibt. Dies wird durch Universal-Referenzen (T&&) und std::forward erreicht.

snippet.cpp

cpp

1

2

3

4

5

6

7

template <typename T>
void wrapper(T&& arg) {
    target(std::forward<T>(arg));
}
 
// target(int&);  // Lvalue
// target(int&&); // Rvalue

performancefunctions

C++ · ExperteSnippet

Das Curiously Recurring Template Pattern (CRTP)

CRTP ist eine Technik, bei der eine Klasse von einer Template-Instanziierung erbt, die sie selbst als Argument verwendet. Dies ermöglicht statischen Polymorphismus (Dispatch zur Kompilierzeit) und vermeidet den Overhead von virtuellen Methodentabellen (VTable).

snippet.cpp

cpp

1

2

3

4

5

6

7

8

9

10

11

12

template <typename Derived>
class Base {
public:
    void interface() {
        static_cast<Derived*>(this)->implementation();
    }
};
 
class Derived : public Base<Derived> {
public:
    void implementation() { /* ... */ }
};

oopperformance

C++ · ExperteSnippet

SFINAE mit std::enable_if

Substitution Failure Is Not An Error (SFINAE) erlaubt es dem Compiler, Template-Überladungen zu ignorieren, die zu ungültigem Code führen würden. std::enable_if_t nutzt dies, um eine Funktion nur dann zu aktivieren, wenn eine bestimmte Bedingung zur Kompilierzeit (z. B. Ganzzahltyp) erfüllt ist.

snippet.cpp

cpp

1

2

3

4

5

6

7

8

9

template <typename T>
std::enable_if_t<std::is_integral_v<T>, T>
increment(T value) {
    return value + 1;
}
 
// Usage:
// auto a = increment(5);    // Compiles
// auto b = increment(3.14); // Compiler Error

syntaxfunctions

C++ · ExperteSnippet

Fold Expressions für variadische Templates

Die in C++17 eingeführten Fold Expressions vereinfachen Operationen auf variadischen Template-Parameterpaketen. Anstelle von rekursiven Template-Aufrufen kann ein einzelner Ausdruck verwendet werden, um einen Operator auf alle Elemente im Paket anzuwenden.

snippet.cpp

cpp

1

2

3

4

5

6

7

template <typename... Args>
auto sum(Args... args) {
    return (... + args);
}
 
// Usage:
// int total = sum(1, 2, 3, 4, 5); // 15

syntaxfunctions

C++ · ExperteSnippet

C++20 Coroutinen: Minimales Promise-Interface

C++20-Coroutinen sind Funktionen, die ihre Ausführung unterbrechen und fortsetzen können. Sie werden durch einen 'promise_type' gesteuert, der das Verhalten der Coroutinen-State-Machine definiert, z. B. wo sie anfangs unterbrochen wird.

snippet.cpp

cpp

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

#include <coroutine>
#include <iostream>
 
struct Resumable {
    struct promise_type {
        Resumable get_return_object() { return {}; }
        std::suspend_always initial_suspend() { return {}; }
        std::suspend_always final_suspend() noexcept { return {}; }
        void return_void() {}
        void unhandled_exception() {}
    };
};
 
Resumable simple_coro() {
    std::cout << "Step 1\n";
    co_await std::suspend_always{};
    std::cout << "Step 2\n";
}
 
int main() {
    auto handle = simple_coro(); // Suspended at start
}

functionsperformance

C++ · ExperteSnippet

C++23 Explizite Objektparameter (Deduced This)

C++23 führte 'deduced this' ein, wodurch Elementfunktionen 'this' als expliziten Parameter entgegennehmen können. Dies vereinfacht das Schreiben von Code, der von der Value-Category (lvalue/rvalue) oder den cv-Qualifikatoren des aufrufenden Objekts abhängt, ohne Funktionen duplizieren zu müssen.

snippet.cpp

cpp

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

#include <iostream>
#include <typeinfo>
 
struct Logger {
    template <typename Self>
    void log_type(this Self&& self) {
        std::cout << "Called on type: " << typeid(Self).name() << "\n";
    }
};
 
int main() {
    Logger l;
    l.log_type(); // Deduces Logger&
    std::move(l).log_type(); // Deduces Logger&&
}

syntaxoop

C++ · ExperteSnippet

C++20 Concepts und Requires-Klauseln

Concepts ermöglichen es, semantische Anforderungen an Template-Argumente zu definieren. Anstelle von kryptischen Fehlermeldungen tief aus einem Template heraus prüft der Compiler die Einschränkung direkt am Aufrufort, was zu wesentlich klareren Fehlermeldungen und einer besseren Code-Dokumentation führt.

snippet.cpp

cpp

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

#include <concepts>
#include <iostream>
 
template <typename T>
concept Arithmetic = std::is_arithmetic_v<T>;
 
template <Arithmetic T>
T calculate_mean(T a, T b) {
    return (a + b) / 2;
}
 
int main() {
    std::cout << calculate_mean(10, 20) << "\n";
    // calculate_mean("string", "error"); // Compile error
}

syntaxfunctions