Modern C++ 简介

#define offsetof(type, member) ((size_t) &((type *)0)->member)
#define container_of(ptr, type, member) ({          \
        const typeof( ((type *)0)->member ) *__mptr = (const typeof( ((type *)0)->member ) *)(ptr); \
        (type *)( (char *)__mptr - offsetof(type,member) );})

int &&rvalueRef = 5; // rvalueRef is a rvalue reference to an integer

#include <vector>
#include <utility> // for std::move

std::vector<int> vec1 = {1, 2, 3, 4, 5};
std::vector<int> vec2 = std::move(vec1); // move vec1 to vec2

class MyClass {
public:
    MyClass(size_t size) : size_(size) {
        data_ = new int[size_];
    }
    // move constructor
    MyClass(MyClass &&other) noexcept : data_(other.data_), size_(other.size_) {
        // 通常情况下需要将 other 置于一个有效但空的状态
        other.data_ = nullptr; // leave other in a valid state
        other.size_ = 0;
    }
    // move assignment operator
    MyClass &operator=(MyClass &&other) noexcept {
        if (this != &other) {
            delete[] data_; // release current resource
            data_ = other.data_;
            size_ = other.size_;
            other.data_ = nullptr; // leave other in a valid state
            other.size_ = 0;
        }
        return *this;
    }
    ~MyClass() {
        delete[] data_;
    }
private:
    int *data_;
    size_t size_;
}

template<typename T>
void func(T &&param) { // param is a universal reference
    // ...
}
int x = 10;
func(x); // T is deduced as int&, param is int&&
func(20); // T is deduced as int, param is int&&

template<typename T>
void func(T &param) { // param is an lvalue reference
    // ...
}
int x = 10;
func(x); // T is deduced as int, param is int&
func(20); // error: cannot bind rvalue to lvalue reference

#include <utility> // for std::forward
template<typename T, typename... Args>
void wrapper(Args&&... args) {
    // do some pre-processing
    // then forward the arguments to another function
    func(std::forward<Args>(args)...); // perfect forwarding
}

#include <memory>
int *ptr = new int[100]; // allocate memory
std::unique_ptr<int[]> p1(ptr); // wrap it in a unique_ptr

// std::unique_ptr<int[]> p2 = p1; // error: cannot copy unique_ptr
std::unique_ptr<int[]> p2 = std::move(p1); // move ownership to p2

#include <memory>
std::shared_ptr<int> p1(new int(42)); // create a shared_ptr
std::shared_ptr<int> p2 = p1; // copy p1 to p2
// now both p1 and p2 share ownership of the same memory

auto p1 = std::make_unique<int[]>(100); // create a unique_ptr
auto p2 = std::make_unique<MyStruct>(); // create a unique_ptr to MyStruct
auto p3 = std::make_shared<int>(42); // create a shared_ptr

int x = 42;
decltype(x) y = x; // y is of type int

template<typename T1, typename T2>
auto add(T1 a, T2 b) -> decltype(a + b) {
    return a + b;
}

auto x = 42; // x is of type int
auto y = 3.14; // y is of type double
auto vec = std::vector<int>{1, 2, 3}; // vec is of type std::vector<int>

std::vector<int> vec = {1, 2, 3, 4, 5};
for (auto it = vec.begin(); it != vec.end(); ++it) {
    // ...
}

void foo(auto &&a, auto &&b) {
    // ...
}

template<typename T1, typename T2>
void foo(T1 &&a, T2 &&b) {
    // ...
}

template<typename T1, typename T2>
auto add(T1 &&a, T2 &&b) -> decltype(std::forward<T1>(a) + std::forward<T2>(b)) {
    return std::forward<T1>(a) + std::forward<T2>(b);
}

const int x = 42;
auto y = x; // y is of type int, const is ignored
decltype(auto) z = x; // z is of type const int, const is preserved

template<typename Container>
decltype(auto) getElement(Container &&c, size_t index) {
    // if c is an lvalue (vector<int>&), returns int&
    // if c is an rvalue (vector<int>&&), returns int
    return std::forward<Container>(c)[index];
}

std::vector<int> vec = {1, 2, 3};
decltype(auto) elem1 = getElement(vec, 0); // elem1 is int&
decltype(auto) elem2 = getElement(std::vector<int>{4, 5, 6}, 0); // elem2 is int

template<class OpType, typename... Args>
OpType OpBuilder::create<OpType>(Location loc, Args&&... args) {
    return OpType::create(loc, std::forward<Args>(args)...);
}

OpBuilder builder;
Location loc = ...;
auto allocOp = builder.create<AllocOp>(loc, /* MemRefType */ type, /* Attribute */ attr);

OpBuilder::create<AllocOp, MemRefType, Attribute>(Location loc, MemRefType&& type, Attribute&& attr) {
    return AllocOp::create(loc, std::forward<MemRefType>(type), std::forward<Attribute>(attr));
}

[capture](parameters) -> return_type {
    // function body
}

int x = 10;
auto lambda = [x](int y) -> int {
    return x + y;
};
int result = lambda(5); // result is 15

#include <algorithm>
#include <vector>
std::vector<int> vec = {1, 2, 3, 4, 5};
std::for_each(vec.begin(), vec.end(), [](int &n) {
    n *= 2; // double each element
});

constexpr int square(int x) {
    return x * x;
}
constexpr int value = square(5); // value is 25, computed at compile time

constexpr int size = 10;
int arr[size]; // valid, size is a compile-time constant

// force compile-time evaluation
consteval size_t compile_time_hash(const char* str) {
    size_t hash = 5381;
    while (*str) {
        hash = ((hash << 5) + hash) + *str++; // djb2 hash
    }
    return hash;
}

constexpr size_t USER_ID_HASH = compile_time_hash("user_id");

void runtime_input_test(const char* input) {
    // 错误！因为 compile_time_hash 是 consteval，它不能在运行时调用。
    // 这提供了极强的安全性保证：如果哈希值需要在运行时计算，则说明
    // 程序员代码有逻辑错误或使用了不适当的输入。
    // size_t runtime_hash = compile_time_hash(input); 
}

template<typename T>
void print_type_info() {
    if constexpr (std::is_integral_v<T>) {
        std::cout << "T is an integral type." << std::endl;
    } else {
        std::cout << "T is not an integral type." << std::endl;
    }
}

print_type_info<int>();
// will specialize to:
void print_type_info<int>() {
    std::cout << "T is an integral type." << std::endl;
}
print_type_info<double>();
// will specialize to:
void print_type_info<double>() {
    std::cout << "T is not an integral type." << std::endl;
}

#include <iostream>
#include <type_traits>

// check if T supports ostream operator<<
template<typename T>
struct supports_ostream {
private:
    // try to instantiate this function template
    template<typename U>
    static auto test(U* u) -> decltype(std::cout << *u, std::true_type{});

    // fallback if above is not valid
    static std::false_type test(...);

public:
    static constexpr bool value = std::is_same_v<decltype(test((T*)nullptr)), std::true_type>;
};

// generic print function
template<typename T>
void print(const T& value) {
    // key point: use if constexpr to conditionally compile code
    if constexpr (supports_ostream<T>::value) {
        // branch 1: T supports stream operator
        std::cout << "Printable via stream: " << value << std::endl;
    } else {
        // branch 2: T does not support stream operator
        std::cout << "Type is not stream printable. Printing fallback message." << std::endl;
    }
}

// create two test structs
struct Printable {
    int x = 42;
};
// overload stream operator for Printable
std::ostream& operator<<(std::ostream& os, const Printable& p) {
    return os << "Printable{" << p.x << "}";
}
// we do not overload stream operator for NotPrintable
struct NotPrintable {
    std::string name = "SecretData";
};

int main() {
    // call print with integral type
    print(100);

    Printable p;
    print(p); 

    NotPrintable np;
    print(np); // will not attempt to use stream operator

    return 0;
}

#include <iostream>
constexpr int factorial(int n) {
    if consteval {
        // compile-time path
        return (n <= 1) ? 1 : n * factorial(n - 1);
    } else {
        // runtime path
        int result = 1;
        for (int i = 2; i <= n; ++i) {
            result *= i;
        }
        return result;
    }
}

int main() {
    const int n = 5;
    constexpr int compile_time_result = factorial(n); // computed at compile time, no runtime overhead
    std::cout << "Compile-time factorial(5): " << compile_time_result << std::endl;

    int m;
    std::cout << "Enter a number to compute factorial at runtime: ";
    std::cin >> m;
    int runtime_result = factorial(m); // computed at runtime
    std::cout << "Runtime factorial(" << m << "): " << runtime_result << std::endl;

    return 0;
}

for (declaration : expression) {
    // loop body
}

#include <vector>
std::vector<int> vec = {1, 2, 3, 4, 5};
for (int n : vec) {
    std::cout << n << " "; // print each element
}

for (auto &n : vec) {
    n *= 2; // double each element
}

auto [var1, var2, ...] = expression;

#include <map>
std::map<std::string, int> myMap = {
    {"one", 1}, 
    {"two", 2}, 
    {"three", 3}
};

for (const auto& [key, value] : myMap) {
    std::cout << key << ": " << value << std::endl;
}

for (const auto& [key, _] : myMap) {
    std::cout << "Key: " << key << std::endl;
}

t: tuple[int, str] = (42, "hello")
num, text = t
print(num)
print(text)

int x{42}; // direct list initialization
std::vector<int> vec{1, 2, 3, 4, 5}; // direct list initialization of vector

int y = {42}; // copy list initialization
std::vector<int> vec2 = {1, 2, 3, 4, 5}; // copy list initialization of vector

struct Point {
    int x;
    int y;
};
Point p{10, 20}; // aggregate initialization
int arr[3] = {1, 2, 3}; // aggregate initialization of array

#include <initializer_list>
void foo(std::initializer_list<int> list) {
    for (int n : list) {
        std::cout << n << " ";
    }
}
foo({1, 2, 3, 4, 5}); // initialize with an initializer list

#include <optional>
std::optional<int> findValue(bool found) {
    if (found) {
        return 42; // return a value
    } else {
        return std::nullopt; // return no value
    }
}
int main() {
    auto result = findValue(true);
    if (result) {
        std::cout << "Value found: " << *result << std::endl;
    } else {
        std::cout << "No value found." << std::endl;
    }
    return 0;
}  

#include <variant>
#include <iostream>
std::variant<int, double, std::string> createVariant(int type) {
    switch (type) {
        case 0:
            return 42; // int
        case 1:
            return 3.14; // double
        case 2:
            return std::string("hello"); // string
        default:
            return {}; // default to empty variant
    }
}

auto var = createVariant(1); // create a variant holding a double
try {
    double d = std::get<double>(var); // get the double value
    std::cout << "Double value: " << d << std::endl;
} catch (const std::bad_variant_access& e) {
    std::cout << "Variant does not hold a double." << std::endl;
}
std::visit([](auto&& arg) {
    std::cout << "Variant holds: " << arg << std::endl;
}, var);

#include <type_traits>
template<typename T>
void checkType() {
    if constexpr (std::is_integral_v<T>) {
        std::cout << "T is an integral type." << std::endl;
    } else if constexpr (std::is_floating_point_v<T>) {
        std::cout << "T is a floating-point type." << std::endl;
    } else {
        std::cout << "T is neither integral nor floating-point." << std::endl;
    }
}

#include <concepts>
template<typename T>
concept Integral = std::is_integral_v<T>;
template<Integral T>
T add(T a, T b) {
    return a + b;
}

template<typename T>
concept C = requires {
    typename T::inner; // T must have a nested type named inner
    typename S<T>; // require class template specialization
}

// compound requirements
template<typename T>
concept C2 = requires(T a) {
    {*x} -> std::convertible_to<typename T::inner>;
    {x + 1} -> std::same_as<int>;
}

template<class T, class U = T>
concept Swappable = requires(T&& t, U&& u) {
    swap(std::forward<T>(t), std::forward<U>(u));
    swap(std::forward<U>(u), std::forward<T>(t));
};

#include <ranges>
std::vector<int> vec = {1, 2, 3, 4, 5};
// create a view that filters even numbers
auto even_view = vec | std::views::filter([](int n) { return n % 2 == 0; });
// iterate over the view
for (int n : even_view) {
    std::cout << n << " "; // prints 2 4
}

auto processed_view = vec 
    | std::views::filter([](int n) { return n % 2 == 0; }) // filter even numbers
    | std::views::transform([](int n) { return n * n; }); // square each number
for (int n : processed_view) {
    std::cout << n << " "; // prints 4 16
}

#include <format>
std::string message = std::format("Hello, {}! You have {} new messages.", "Alice", 5);
std::cout << message << std::endl; // prints "Hello, Alice! You have 5 new messages."