Functions⚓︎

class Window {
public:
    ...
    std::string name() const;
    virtual void display() const;
};
class WindowWithScrollBars : public Window {
public:
    ...
    virtual void display() const;
};

void printNameAndDisplay(Window w) {
    std::cout << w.name();
    w.display();
}

WindowWithScrollBars wwsb;
printNameAndDisplay(wwsb);

void printNameAndDisplay(const Window& w) {
    std::cout << w.name();
    w.display();
}

class class_c {
public:
    int max;
    int min;
    int middle;

    class_c(int my_max) {
        max = my_max > 0 ? my_max : 10;
        min = 1;
        middle = (max + min) / 2;
        std::cout << "Delegated to: class_c(int)" << std::endl;
    }

    // 此构造函数委托给 class_c(int)
    class_c(int my_max, int my_min) : class_c(my_max) { // 委托调用
        // max 已经由 class_c(my_max) 初始化
        min = my_min > 0 && my_min < max ? my_min : 1;
        middle = (this->max + this->min) / 2; // 使用 this-> 明确访问成员
        std::cout << "Delegated to: class_c(int, int)" << std::endl;
    }

    // 此构造函数委托给 class_c(int, int)
    class_c(int my_max, int my_min, int my_middle) : class_c(my_max, my_min) { // 委托调用
        // max 和 min 已经由 class_c(my_max, my_min) 初始化
        middle = my_middle < this->max && my_middle > this->min ? my_middle : (this->max + this->min) / 2;
        std::cout << "Called: class_c(int, int, int)" << std::endl;
    }
};

int harpo(int n, int m = 4, int j = 5);

// int chico(int n, int m = 6, int j); // 错误! j 没有默认值，但 m 有

int groucho(int k = 1, int m = 2, int n = 3); // 合法

// 调用示例
int beeps;
beeps = harpo(2);       // 等价于 harpo(2, 4, 5);
beeps = harpo(1, 8);    // 等价于 harpo(1, 8, 5);
beeps = harpo(8, 7, 6); // 所有参数均提供，不使用默认值

#include <iostream>
#include <vector>
#include <algorithm>
#include <string>

int main() {
    // 1. 基本的 Lambda，无捕获，无参数，隐式返回 void
    [] { std::cout << "Hello from Lambda!" << std::endl; }(); // 定义并立即调用

    // 2. 带参数的 Lambda
    auto add = [](int a, int b) -> int {
        return a + b;
    };
    std::cout << "Sum: " << add(5, 3) << std::endl; // 输出: Sum: 8

    // 3. 自动返回类型推断（省略 -> int）
    auto multiply = [](double a, double b) {
        return a * b;
    };
    std::cout << "Product: " << multiply(2.5, 4.0) << std::endl; // 输出: Product: 10.0

    // 4. 捕获子句示例
    int x = 10;
    int y = 20;

    // 按值捕获 x 和 y
    auto capture_by_value = [x, y]() {
        // x 和 y 在这里是副本，修改它们不会影响外部的 x 和 y
        std::cout << "Inside by_value: x = " << x << ", y = " << y << std::endl;
        // x = 100; // 编译错误，因为 x 是 const（除非使用 mutable）
    };
    capture_by_value();

    // 按引用捕获 x 和 y
    auto capture_by_reference = [&x, &y]() {
        x = 100; // 修改会影响外部的 x
        y = 200; // 修改会影响外部的 y
        std::cout << "Inside by_reference: x = " << x << ", y = " << y << std::endl;
    };
    capture_by_reference();
    std::cout << "Outside after by_reference: x = " << x << ", y = " << y << std::endl; // 输出: x = 100, y = 200

    // 隐式按值捕获所有可见变量
    int z = 30;
    auto capture_all_by_value = [=]() {
        std::cout << "Inside all_by_value: x = " << x << ", y = " << y << ", z = " << z << std::endl;
    };
    capture_all_by_value();

    // 隐式按引用捕获所有可见变量
    int w = 40;
    auto capture_all_by_reference = [&]() {
        x = 1; y = 2; z = 3; w = 4;
        std::cout << "Inside all_by_reference: x = " << x << ", y = " << y << ", z = " << z << ", w = " << w << std::endl;
    };
    capture_all_by_reference();
    std::cout << "Outside after all_by_reference: x = " << x << ", y = " << y << ", z = " << z << ", w = " << w << std::endl;

    // 5. mutable 关键字
    int val = 5;
    auto mutable_lambda = [val]() mutable {
        val = 10; // 现在可以修改按值捕获的 val 的副本
        std::cout << "Inside mutable_lambda, val = " << val << std::endl;
    };
    mutable_lambda();
    std::cout << "Outside mutable_lambda, val = " << val << std::endl; // 输出: 5（外部的 val 未改变）

    // 6. 在 STL 算法中使用 Lambda
    std::vector<int> numbers = {1, 5, 2, 8, 3, 7};
    int threshold = 4;

    // 计算大于 threshold 的元素数量
    int count = std::count_if(numbers.begin(), numbers.end(), [threshold](int n) {
        return n > threshold;
    });
    std::cout << "Numbers greater than " << threshold << ": " << count << std::endl; // 输出: 3

    // 打印所有元素
    std::for_each(numbers.begin(), numbers.end(), [](int n) {
        std::cout << n << " ";
    });
    std::cout << std::endl;

    // 7. C++14: 泛型 Lambda（使用 auto 作为参数类型）
    auto generic_add = [](auto a, auto b) {
        return a + b;
    };
    std::cout << "Generic add (int): " << generic_add(10, 20) << std::endl;
    std::cout << "Generic add (double): " << generic_add(1.5, 2.5) << std::endl;
    std::cout << "Generic add (string): " << generic_add(std::string("Hello, "), std::string("World!")) << std::endl;


    // 8. C++14: 初始化捕获（广义 Lambda 捕获）
    std::string message = "Original message";
    auto generalized_capture_lambda = [captured_message = std::move(message)]() {
        std::cout << "Inside generalized_capture_lambda: " << captured_message << std::endl;
        // message 在这里已经被移走，通常不应再使用（除非重新赋值）
    };
    generalized_capture_lambda();
    std::cout << "After generalized_capture_lambda, message: \"" << message << "\"" << std::endl; // message 可能是空的或处于未定义状态

    return 0;
}

class __LambdaUniqueName__ {
private:
    int __x; // 按值捕获
    int& __y; // 按引用捕获

public:
    __LambdaUniqueName__(int x_val, int& y_ref) : __x(x_val), __y(y_ref) {}

    auto operator()() const { // 如果没有 mutable，则 operator() 是 const
        // Lambda 函数体
    }
};

#include <iostream>
#include <vector>
#include <ranges>
#include <algorithm> // for std::ranges::for_each

int main() {
    std::vector<int> numbers = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

    auto even_numbers = [](int n) { return n % 2 == 0; };
    auto square = [](int n) { return n * n; };

    // 使用管道操作符 | 组合视图
    auto result_view = numbers
                    | std::views::filter(even_numbers) // 筛选偶数 {2, 4, 6, 8, 10}
                    | std::views::transform(square)    // 平方 {4, 16, 36, 64, 100}
                    | std::views::take(3);             // 取前3个 {4, 16, 36}

    // 此时，上面的操作都是惰性定义的，并没有真正执行计算。
    // 当我们迭代 result_view 时，计算才会按需发生。
    std::cout << "Processed numbers: ";
    for (int n : result_view) { // 迭代 result_view，触发计算
        std::cout << n << " ";
    }
    std::cout << std::endl; // 输出: Processed numbers: 4 16 36

    // 也可以直接传递给 ranges 算法
    std::cout << "Processed numbers (using for_each): ";
    std::ranges::for_each(numbers
                        | std::views::filter(even_numbers)
                        | std::views::transform(square)
                        | std::views::take(3),
                        [](int n){ std::cout << n << " "; });
    std::cout << std::endl; // 输出: Processed numbers (using for_each): 4 16 36

    return 0;
}