【C++ 可调用对象的应用】C++设计模式与现代编程技巧：深入可调用对象的世界

#include <iostream>
#include <functional>
/**
 * @brief 可调用对象策略A
 * 
 * StrategyA 定义了具体的策略行为，通过重载 operator() 实现。
 */
class StrategyA {
public:
    void operator()() const {
        std::cout << "Executing Strategy A" << std::endl;
    }
};
/**
 * @brief 可调用对象策略B
 * 
 * StrategyB 定义了另一种策略行为，通过重载 operator() 实现。
 */
class StrategyB {
public:
    void operator()() const {
        std::cout << "Executing Strategy B" << std::endl;
    }
};
/**
 * @brief 上下文
 * 
 * Context 使用 std::function 包装策略，允许在运行时动态更换策略。
 */
class Context {
private:
    std::function<void()> strategy_;
public:
    Context(std::function<void()> strategy) : strategy_(strategy) {}
    void set_strategy(std::function<void()> strategy) {
        strategy_ = strategy;
    }
    void execute_strategy() const {
        strategy_();
    }
};
/**
 * @brief 主函数示例
 * 
 * main 函数演示了如何使用函数对象作为策略，并在 Context 中动态切换。
 */
int main() {
    Context context(StrategyA());  // 使用策略A
    context.execute_strategy();
    context.set_strategy(StrategyB());  // 更换为策略B
    context.execute_strategy();
    return 0;
}

#include <iostream>
#include <vector>
#include <memory>
/**
 * @brief 命令接口
 * 
 * 定义了可执行操作的基本接口。
 */
class Command {
public:
    virtual ~Command() {}
    virtual void operator()() = 0; // 重载函数调用操作符
};
/**
 * @brief 具体命令类 - 打开命令
 * 
 * 实现了打开操作的具体命令。
 */
class OpenCommand : public Command {
public:
    void operator()() override {
        std::cout << "Open command executed." << std::endl;
    }
};
/**
 * @brief 具体命令类 - 关闭命令
 * 
 * 实现了关闭操作的具体命令。
 */
class CloseCommand : public Command {
public:
    void operator()() override {
        std::cout << "Close command executed." << std::endl;
    }
};
/**
 * @brief 命令调用者
 * 
 * 负责调用命令对象以执行请求。
 */
class Invoker {
private:
    std::vector<std::shared_ptr<Command>> commands;
public:
    void addCommand(std::shared_ptr<Command> command) {
        commands.push_back(command);
    }
    void executeCommands() {
        for (auto& command : commands) {
            (*command)(); // 使用函数调用操作符执行命令
        }
    }
};
// 主函数 - 示范命令模式的使用
int main() {
    // 创建命令对象
    auto openCommand = std::make_shared<OpenCommand>();
    auto closeCommand = std::make_shared<CloseCommand>();
    // 创建并配置调用者
    Invoker invoker;
    invoker.addCommand(openCommand);
    invoker.addCommand(closeCommand);
    // 执行命令
    invoker.executeCommands();
    return 0;
}

#include <iostream>
#include <list>
#include <functional>
// Subject类，负责添加、删除和通知观察者
class Subject {
public:
    void attach(const std::function<void(int)> &observer) {
        observers.push_back(observer);
    }
    void detach(const std::function<void(int)> &observer) {
        observers.remove(observer);
    }
    void notify(int value) {
        for (auto &observer : observers) {
            observer(value);
        }
    }
private:
    std::list<std::function<void(int)>> observers;
};
/**
 * 一个简单的观察者实现
 * @param value 被观察的值
 */
void simpleObserver(int value) {
    std::cout << "Simple Observer: Value is " << value << std::endl;
}
/**
 * 另一个观察者实现，作为函数对象
 */
class ComplexObserver {
public:
    void operator()(int value) {
        std::cout << "Complex Observer: Value is " << value << std::endl;
    }
};
int main() {
    Subject subject;
    ComplexObserver complexObserver;
    // 添加观察者
    subject.attach(simpleObserver);
    subject.attach(complexObserver);
    // 通知所有观察者
    subject.notify(42);
    // 移除特定观察者
    subject.detach(complexObserver);
    subject.notify(100);
    return 0;
}

#include <iostream>
#include <vector>
// 基础图形类
class Shape {
public:
    virtual ~Shape() = default;
    virtual void accept(class Visitor& v) = 0;
};
// 圆形类
class Circle : public Shape {
public:
    void accept(Visitor& v) override;
    // 圆形特有的方法
    void drawCircle() const {
        std::cout << "Drawing Circle" << std::endl;
    }
};
// 矩形类
class Rectangle : public Shape {
public:
    void accept(Visitor& v) override;
    // 矩形特有的方法
    void drawRectangle() const {
        std::cout << "Drawing Rectangle" << std::endl;
    }
};
// 访问者类
class Visitor {
public:
    // 对圆形的访问
    void operator()(Circle& circle) {
        circle.drawCircle();
    }
    // 对矩形的访问
    void operator()(Rectangle& rectangle) {
        rectangle.drawRectangle();
    }
};
void Circle::accept(Visitor& v) {
    v(*this);
}
void Rectangle::accept(Visitor& v) {
    v(*this);
}
int main() {
    std::vector<Shape*> shapes = {new Circle(), new Rectangle()};
    Visitor visitor;
    for (auto* shape : shapes) {
        shape->accept(visitor);
    }
    // 清理资源
    for (auto* shape : shapes) {
        delete shape;
    }
    return 0;
}

#include <iostream>
#include <memory>
// 抽象产品类
class Product {
public:
    virtual ~Product() {}
    virtual void Operation() const = 0;
};
// 具体产品类A
class ConcreteProductA : public Product {
public:
    void Operation() const override {
        std::cout << "Operation of ConcreteProductA\n";
    }
};
// 具体产品类B
class ConcreteProductB : public Product {
public:
    void Operation() const override {
        std::cout << "Operation of ConcreteProductB\n";
    }
};
/**
 * @brief 工厂类，利用函数调用符实现
 *
 * 工厂类通过重载operator()来创建不同的产品实例。
 * 这里使用了简单工厂模式的概念，通过参数决定创建哪种类型的产品。
 */
class Factory {
public:
    std::unique_ptr<Product> operator()(const std::string& type) const {
        if (type == "A") {
            return std::make_unique<ConcreteProductA>();
        } else if (type == "B") {
            return std::make_unique<ConcreteProductB>();
        } else {
            throw std::invalid_argument("Unknown product type");
        }
    }
};
int main() {
    Factory factory;
    // 创建产品A
    auto productA = factory("A");
    productA->Operation();
    // 创建产品B
    auto productB = factory("B");
    productB->Operation();
    return 0;
}

#include <iostream>
/**
 * @brief 目标接口（Target Interface）
 * 
 * 这是客户端所期望的接口，适配器需要将被适配者的接口转换为这种形式。
 */
class Target {
public:
    virtual void Request() const = 0;
};
/**
 * @brief 被适配者类（Adaptee）
 * 
 * 这个类有一个特殊的接口，需要通过适配器进行转换以满足客户端的需求。
 */
class Adaptee {
public:
    void SpecificRequest() const {
        std::cout << "Specific request of Adaptee is called." << std::endl;
    }
};
/**
 * @brief 适配器类（Adapter）
 * 
 * 适配器实现了目标接口，并通过重载函数调用操作符实现接口的适配。
 */
class Adapter : public Target, private Adaptee {
public:
    Adapter() {}
    void Request() const override {
        // 调用被适配者的特定请求
        SpecificRequest();
    }
    // 重载函数调用操作符
    void operator()() const {
        Request();
    }
};
/**
 * @brief 客户端代码（Client Code）
 * 
 * 客户端代码支持所有遵循目标接口的类。
 */
void ClientCode(const Target& target) {
    // 调用目标接口的请求方法
    target.Request();
}
// 主函数
int main() {
    std::cout << "Client: I can work just fine with the Target objects:\n";
    Target* target = new Target();
    ClientCode(*target);
    std::cout << "\n";
    std::cout << "Client: The Adaptee class has a weird interface. See, I don't understand it:\n";
    Adaptee* adaptee = new Adaptee();
    adaptee->SpecificRequest();
    std::cout << "\n";
    std::cout << "Client: But I can work with it via the Adapter:\n";
    Adapter* adapter = new Adapter();
    ClientCode(*adapter);
    delete target;
    delete adaptee;
    delete adapter;
    return 0;
}

[ capture_clause ] ( parameters ) -> return_type {
    function_body
}

std::vector<int> numbers = {1, 2, 3, 4, 5, 6};
std::for_each(numbers.begin(), numbers.end(), [](int number) {
    if (number % 2 == 0) {
        std::cout << number << " ";
    }
});

class CompareCounter {
    int count;
public:
    CompareCounter() : count(0) {}
    bool operator()(int a, int b) {
        ++count;
        return a < b;
    }
    int getCount() const {
        return count;
    }
};

class Context {
    std::function<void()> strategy;
public:
    void setStrategy(const std::function<void()>& strategyFunc) {
        strategy = strategyFunc;
    }
    void executeStrategy() {
        if(strategy) {
            strategy();
        }
    }
};
// 使用Lambda表达式设置不同的策略
Context context;
context.setStrategy([](){ std::cout << "Strategy A" << std::endl; });
context.executeStrategy();
context.setStrategy([](){ std::cout << "Strategy B" << std::endl; });
context.executeStrategy();

class Observer {
public:
    virtual void update() = 0
;
    virtual ~Observer() {}
};
class ConcreteObserver : public Observer {
    std::string name;
public:
    ConcreteObserver(const std::string& name) : name(name) {}
    void update() override {
        std::cout << "Observer " << name << " is notified." << std::endl;
    }
};
class Subject {
    std::vector<std::reference_wrapper<Observer>> observers;
public:
    void attach(Observer& observer) {
        observers.push_back(observer);
    }
    void notify() {
        for (auto& observer : observers) {
            observer.get().update();
        }
    }
};

class Command {
public:
    virtual void execute() = 0;
    virtual ~Command() {}
};
class ConcreteCommand : public Command {
    std::function<void()> action;
public:
    ConcreteCommand(const std::function<void()>& action) : action(action) {}
    void execute() override {
        action();
    }
};
// 使用Lambda表达式作为命令的具体操作
ConcreteCommand command([](){ std::cout << "Performing a command action." << std::endl; });
command.execute();

/**
 * @brief Employee 结构体，表示员工信息
 */
struct Employee {
    std::string name; ///< 员工姓名
    int age;          ///< 员工年龄
    double salary;    ///< 员工薪资
    /**
     * @brief 构造函数
     * @param name 员工姓名
     * @param age 员工年龄
     * @param salary 员工薪资
     */
    Employee(std::string name, int age, double salary) : name(name), age(age), salary(salary) {}
};

/**
 * @brief EmployeeComparator 函数对象，用于比较两个员工对象
 */
class EmployeeComparator {
public:
    /**
     * @brief 比较两个Employee对象的函数
     * @param e1 第一个Employee对象
     * @param e2 第二个Employee对象
     * @return 如果e1应该排在e2前面，则返回true；否则返回false
     */
    bool operator()(const Employee& e1, const Employee& e2) const {
        if (e1.age < e2.age) {
            return true;
        } else if (e1.age == e2.age) {
            return e1.salary > e2.salary;
        }
        return false;
    }
};

int main() {
    std::vector<Employee> employees = {
        {"Alice", 30, 5000.0},
        {"Bob", 25, 4000.0},
        {"Charlie", 30, 4500.0}
    };
    std::sort(employees.begin(), employees.end(), EmployeeComparator());
    for (const auto& e : employees) {
        std::cout << e.name << ", " << e.age << ", " << e.salary << std::endl;
    }
    return 0;
}

#include <iostream>
#include <string>
#include <functional>
/**
 * @brief ResponseHandler 类，用于处理网络响应
 * 
 * 这个类通过重载 operator() 来提供处理网络响应的功能。
 * 它可以封装不同的逻辑，如解析响应、错误处理等。
 */
class ResponseHandler {
public:
    /**
     * @brief 处理网络响应的函数调用操作符重载
     * 
     * @param response 网络响应的内容
     */
    void operator()(const std::string& response) {
        std::cout << "处理网络响应: " << response << std::endl;
        // 这里可以添加更多的处理逻辑，如解析JSON、更新UI等
    }
};

/**
 * @brief 模拟异步发送网络请求的函数
 * 
 * @param url 请求的URL
 * @param callback 当请求完成时调用的回调函数
 */
void asyncNetworkRequest(const std::string& url, const std::function<void(const std::string&)>& callback) {
    std::cout << "发送网络请求到: " << url << std::endl;
    // 模拟网络操作，这里简单地调用回调函数
    callback("响应内容");
}

int main() {
    ResponseHandler handler; // 创建响应处理器实例
    asyncNetworkRequest("http://example.com", handler); // 发送网络请求并使用handler作为回调
    return 0;
}

#include <iostream>
#include <string>
#include <functional>
/**
 * @class StateManager
 * @brief 管理UI状态的类。
 *
 * StateManager 类使用函数对象来更新UI的状态。
 * 它允许用户设置不同的状态处理逻辑，并在状态变化时调用相应的函数对象。
 */
class StateManager {
public:
    using StateHandler = std::function<void(const std::string&)>;
private:
    StateHandler stateHandler;
public:
    /**
     * @brief 设置状态处理函数。
     * @param handler 一个函数对象，用于处理状态更新。
     */
    void setStateHandler(const StateHandler& handler) {
        stateHandler = handler;
    }
    /**
     * @brief 更新状态。
     * @param newState 新的状态信息。
     */
    void updateState(const std::string& newState) {
        if(stateHandler) {
            stateHandler(newState);
        }
    }
};
// 示例使用
int main() {
    StateManager manager;
    // 设置状态处理逻辑
    manager.setStateHandler([](const std::string& state) {
        std::cout << "UI状态已更新为: " << state << std::endl;
        // 这里可以添加更多的UI更新逻辑
    });
    // 模拟状态更新
    manager.updateState("正在加载");
    manager.updateState("加载完成");
    return 0;
}

#include <iostream>
#include <vector>
#include <thread>
/**
 * @brief 数据处理器类
 *
 * 用于并发处理一系列数据。
 */
class DataProcessor {
public:
    /**
     * @brief 构造一个新的数据处理器对象
     * 
     * @param data 要处理的数据引用
     */
    explicit DataProcessor(std::vector<int>& data) : data_(data) {}
    /**
     * @brief 处理数据的操作
     * 
     * @param index 要处理的数据项的索引
     */
    void operator()(int index) {
        // 这里只是一个示例，实际处理逻辑可能更复杂
        data_[index] *= 2; // 假设我们的处理逻辑是将数据项乘以2
        std::cout << "Processed data at index " << index << ": " << data_[index] << std::endl;
    }
private:
    std::vector<int>& data_; // 数据引用
};
/**
 * @brief 创建并启动多个线程来处理数据
 * 
 * @param data 数据集合
 * @param numThreads 线程数量
 */
void processInMultipleThreads(std::vector<int>& data, int numThreads) {
    DataProcessor processor(data);
    std::vector<std::thread> threads;
    for (int i = 0; i < numThreads; ++i) {
        // 为每个数据项创建一个线程
        threads.emplace_back(processor, i);
    }
    // 等待所有线程完成
    for (auto& t : threads) {
        if (t.joinable()) {
            t.join();
        }
    }
}

//假设我们有一个包含一些整数的向量。我们想要创建几个线程，每个线程对向量中的一个元素进行操作。
//我们将使用之前定义的 `DataProcessor` 和 `processInMultipleThreads` 函数。
测试用例如下：
std::vector<int> data = {1, 2, 3, 4, 5};
int numThreads = data.size();  // 创建与数据量相等的线程数
processInMultipleThreads(data, numThreads);
//这个测试将创建五个线程，每个线程将对数组中的一个元素进行操作。

#include <cmath>
#include <stdexcept>
#include <tuple>
/**
 * @brief QuadraticSolver - 用于解决二元一次方程的类.
 *
 * 该类通过重载 `operator()` 实现了方程求解的功能。
 * 它接受三个系数 a, b, c，并返回方程的根。
 */
class QuadraticSolver {
public:
    /**
     * @brief 重载 `operator()` 以求解二元一次方程.
     * 
     * @param a 方程的二次项系数
     * @param b 方程的一次项系数
     * @param c 方程的常数项
     * @return std::tuple<bool, double, double> 
     *         返回一个元组，包含一个布尔值和两个双精度浮点数。
     *         布尔值表示方程是否有实数解，两个浮点数是方程的根（如果存在）。
     */
    std::tuple<bool, double, double> operator()(double a, double b, double c) {
        // 计算判别式
        double discriminant = b * b - 4 * a * c;
        
        if (discriminant < 0) {
            // 无实数解
            return std::make_tuple(false, 0.0, 0.0);
        } else {
            // 计算并返回根
            double r1 = (-b + std::sqrt(discriminant)) / (2 * a);
            double r2 = (-b - std::sqrt(discriminant)) / (2 * a);
            return std::make_tuple(true, r1, r2);
        }
    }
};

#include <iostream>
int main() {
    QuadraticSolver solver;
    // 定义方程系数
    double a = 1.0, b = -3.0, c = 2.0;
    // 使用函数对象求解方程
    auto [hasRealRoots, root1, root2] = solver(a, b, c);
    // 输出结果
    if (hasRealRoots) {
        std::cout << "The equation has real roots: " << root1 << " and " << root2 << std::endl;
    } else {
        std::cout << "The equation has no real roots." << std::endl;
    }
    return 0;
}

#include <string>
#include <iostream>
/**
 * @class SerialDataProcessor
 * @brief 串口数据处理的函数对象类
 */
class SerialDataProcessor {
public:
    /**
     * @brief 构造函数，可以在此处初始化必要的资源
     */
    SerialDataProcessor() {
        // 初始化操作
    }
    /**
     * @brief 重载 () 操作符，实现串口数据的处理逻辑
     * @param data 从串口接收的数据
     */
    void operator()(const std::string& data) {
        std::cout << "Processing received data: " << data << std::endl;
        // 在这里添加数据处理的具体逻辑
    }
    // 其他必要的成员函数和数据成员
};

int main() {
    SerialDataProcessor dataProcessor;
    // 模拟从串口接收到的数据
    std::string receivedData = "Example data from serial port";
    // 使用函数对象处理数据
    dataProcessor(receivedData);
    return 0;
}

class SpecialDataProcessor : public SerialDataProcessor {
public:
    void operator()(const std::string& data) override {
        std::cout << "Processing special data: " << data << std::endl;
        // 特殊数据处理逻辑
    }
};
int main() {
    SpecialDataProcessor specialDataProcessor;
    // 模拟接收特殊数据
    std::string specialData = "Special data from serial port";
    // 使用特殊的数据处理器处理数据
    specialDataProcessor(specialData);
    return 0;
}

/**
 * @file ObstacleDetector.h
 * @brief 定义障碍物检测模块
 */
#ifndef OBSTACLE_DETECTOR_H
#define OBSTACLE_DETECTOR_H
#include <vector>
/**
 * @brief 传感器数据结构
 */
struct SensorData {
    float x, y; // 位置坐标
    float distance; // 到传感器的距离
};
/**
 * @brief 障碍物信息
 */
struct Obstacle {
    float x, y; // 障碍物位置
    float size; // 障碍物大小
};
/**
 * @class ObstacleDetector
 * @brief 障碍物检测类
 * 
 * 用于从传感器数据中检测障碍物。
 */
class ObstacleDetector {
public:
    /**
     * @brief 构造函数
     */
    ObstacleDetector();
    /**
     * @brief 执行障碍物检测
     * @param data 传感器数据
     * @return 检测到的障碍物列表
     */
    std::vector<Obstacle> operator()(const SensorData& data);
private:
    // 私有成员和方法可以根据需要添加
};
#endif // OBSTACLE_DETECTOR_H

#include "ObstacleDetector.h"
ObstacleDetector::ObstacleDetector() {
    // 初始化代码，例如加载模型、配置参数等
    std::cout << "ObstacleDetector initialized." << std::endl;
}
std::vector<Obstacle> ObstacleDetector::operator()(const SensorData& data) {
    std::vector<Obstacle> detectedObstacles;
    // 示例逻辑：当传感器数据显示距离小于某个阈值时，判定为障碍物
    const float distanceThreshold = 5.0f; // 障碍物检测
    if (data.distance < distanceThreshold) {
        // 假定障碍物大小与距离成反比
        float obstacleSize = 1.0f / data.distance; 
        // 创建一个障碍物实例
        Obstacle obstacle;
        obstacle.x = data.x;
        obstacle.y = data.y;
        obstacle.size = obstacleSize;
        // 将检测到的障碍物添加到列表中
        detectedObstacles.push_back(obstacle);
        std::cout << "Detected obstacle at (" << data.x << ", " << data.y 
                  << ") with size: " << obstacleSize << std::endl;
    }
    return detectedObstacles;
}

#include <iostream>
#include <functional>
#include <dbus/dbus.h>
/**
 * @file dbus_signal_handler.cpp
 * @brief DBus信号处理示例
 *
 * 这个文件展示了如何使用函数对象处理DBus信号。
 */
/**
 * @class DBusSignalHandler
 * @brief 处理DBus信号的类
 *
 * DBusSignalHandler负责接收DBus信号，并将其转发到绑定的处理函数。
 */
class DBusSignalHandler {
public:
    using SignalHandler = std::function<void(const std::string&)>;
private:
    SignalHandler handler; ///< 信号处理函数
public:
    /**
     * 绑定信号处理函数
     * @param newHandler 一个函数对象，用于处理接收到的信号
     */
    void bindSignalHandler(const SignalHandler& newHandler) {
        handler = newHandler;
    }
    /**
     * 处理接收到的DBus信号
     * @param signalData 接收到的信号数据
     */
    void handleSignal(const std::string& signalData) {
        if (handler) {
            handler(signalData);
        } else {
            std::cout << "No handler bound for signal." << std::endl;
        }
    }
};
/**
 * @class MySignalHandler
 * @brief 自定义DBus信号处理函数对象
 *
 * MySignalHandler定义了一个函数调用操作符，用于处理接收到的DBus信号。
 */
class MySignalHandler {
public:
    /**
     * 处理DBus信号
     * @param data 接收到的信号数据
     */
    void operator()(const std::string& data) {
        std::cout << "Received DBus signal with data: " << data << std::endl;
        // 在这里添加更复杂的信号处理逻辑
    }
};
/**
 * 主函数，用于演示DBusSignalHandler和MySignalHandler的使用
 */
int main() {
    DBusSignalHandler signalHandler;
    MySignalHandler myHandler;
    // 绑定函数对象到DBus信号处理器
    signalHandler.bindSignalHandler(myHandler);
    // 模拟接收到的DBus信号
    signalHandler.handleSignal("Sample Data");
    return 0;
}