C++中如何构建对象构建器 流式接口与分步构建复杂对象

#include <string>
#include <optional>
#include <iostream>

// 产品类
class Product {
public:
    // 构造函数私有化，强制通过构建器创建
    Product(std::string name, double price, std::optional<std::string> description)
        : name_(std::move(name)), price_(price), description_(std::move(description)) {}

    void display() const {
        std::cout << "Product: " << name_ << ", Price: " << price_;
        if (description_) {
            std::cout << ", Description: " << *description_;
        }
        std::cout << std::endl;
    }

private:
    std::string name_;
    double price_;
    std::optional<std::string> description_;

    // 友元声明，允许构建器访问私有构造函数
    friend class ProductBuilder;
};

// 产品构建器
class ProductBuilder {
public:
    ProductBuilder() = default;

    ProductBuilder& withName(std::string name) {
        name_ = std::move(name);
        return *this;
    }

    ProductBuilder& withPrice(double price) {
        price_ = price;
        return *this;
    }

    ProductBuilder& withDescription(std::string description) {
        description_ = std::move(description);
        return *this;
    }

    // 构建方法，返回最终产品
    Product build() {
        // 可以在这里添加验证逻辑
        if (!name_.has_value() || !price_.has_value()) {
            throw std::runtime_error("Product must have a name and a price.");
        }
        return Product(name_.value(), price_.value(), description_);
    }

private:
    std::optional<std::string> name_;
    std::optional<double> price_;
    std::optional<std::string> description_;
};

/*
// 使用示例
int main() {
    Product p1 = ProductBuilder()
                     .withName("Laptop")
                     .withPrice(1200.0)
                     .withDescription("Powerful gaming laptop")
                     .build();
    p1.display();

    Product p2 = ProductBuilder()
                     .withName("Mouse")
                     .withPrice(25.0)
                     .build(); // 没有描述
    p2.display();

    // 尝试构建一个不完整的产品 (会抛出异常)
    try {
        Product p3 = ProductBuilder().withName("Keyboard").build();
        p3.display();
    } catch (const std::runtime_error& e) {
        std::cerr << "Error: " << e.what() << std::endl;
    }

    return 0;
}
*/

// 示例：ProductBuilder中withName方法的实现
ProductBuilder& ProductBuilder::withName(std::string name) {
    name_ = std::move(name); // 设置内部状态
    return *this;            // 返回自身引用，实现链式调用
}

#include <string>
#include <iostream>
#include <memory> // For std::unique_ptr

// 假设我们有一个复杂的汽车对象
class Car {
public:
    Car(std::string engine, std::string wheels, std::string color)
        : engine_(std::move(engine)), wheels_(std::move(wheels)), color_(std::move(color)) {}

    void drive() const {
        std::cout << "Driving a " << color_ << " car with " << engine_ << " engine and " << wheels_ << " wheels." << std::endl;
    }
private:
    std::string engine_;
    std::string wheels_;
    std::string color_;
    friend class CarBuilder; // 友元声明
    friend class CarBuilderWithEngine;
    friend class CarBuilderWithWheels;
};

// ---------------------------
// 阶段性构建器接口/类
// ---------------------------

// 初始阶段：只能选择引擎
class CarBuilderWithEngine;
class CarBuilderStart {
public:
    CarBuilderStart() = default;
    CarBuilderWithEngine withEngine(std::string engine);
};

// 第二阶段：已经有了引擎，现在可以安装车轮
class CarBuilderWithWheels;
class CarBuilderWithEngine {
public:
    CarBuilderWithEngine(std::string engine) : engine_(std::move(engine)) {}
    CarBuilderWithWheels withWheels(std::string wheels);
private:
    std::string engine_;
};

// 第三阶段：有了引擎和车轮，现在可以选颜色并最终构建
class CarBuilder { // 最终的构建器，名字可以更通用
public:
    CarBuilder(std::string engine, std::string wheels)
        : engine_(std::move(engine)), wheels_(std::move(wheels)) {}
    CarBuilder& withColor(std::string color);
    Car build();
private:
    std::string engine_;
    std::string wheels_;
    std::string color_;
};

// ---------------------------
// 实现
// ---------------------------

CarBuilderWithEngine CarBuilderStart::withEngine(std::string engine) {
    return CarBuilderWithEngine(std::move(engine));
}

CarBuilderWithWheels CarBuilderWithEngine::withWheels(std::string wheels) {
    return CarBuilderWithWheels(engine_, std::move(wheels));
}

CarBuilder CarBuilderWithWheels::withColor(std::string color) {
    return CarBuilder(engine_, wheels_).withColor(std::move(color)); // 这里有点小技巧，直接构造最终构建器并设置颜色
}

CarBuilder& CarBuilder::withColor(std::string color) {
    color_ = std::move(color);
    return *this;
}

Car CarBuilder::build() {
    if (color_.empty()) { // 强制颜色是最后一个设置的，或者在这里验证
        throw std::runtime_error("Car must have a color.");
    }
    return Car(engine_, wheels_, color_);
}

/*
// 使用示例
int main() {
    // 强制构建顺序：Start -> WithEngine -> WithWheels -> WithColor -> Build
    Car myCar = CarBuilderStart()
                    .withEngine("V8")
                    .withWheels("Sport Rims")
                    .withColor("Red")
                    .build();
    myCar.drive();

    // 编译错误：不能在没有引擎的情况下直接安装车轮
    // CarBuilderStart().withWheels("Standard");

    // 编译错误：不能在没有车轮的情况下直接选颜色
    // CarBuilderStart().withEngine("Electric").withColor("Blue");

    return 0;
}
*/