备案控制台
开发者社区 开发与运维 文章 正文

C++ 职责链模式：轻松实现解耦和扩展性

2024-03-19 44
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
本文涉及的产品
日志服务 SLS，月写入数据量 50GB 1个月
简介： C++ 职责链模式：轻松实现解耦和扩展性

职责链模式简介（Introduction to the Responsibility Chain Pattern）

职责链模式（Chain of Responsibility Pattern）是一种行为型设计模式，它通过将请求处理对象组织成链式结构，使得请求在这些处理对象之间传递，直到一个处理对象负责处理请求。这种模式有助于降低处理对象之间的耦合，同时提高了代码的可扩展性。

职责链模式UML图

+-------------------+     +-----------------------+     +---------------------+
|   Handler         |<----|   ConcreteHandler1    |<----| ConcreteHandler2    |
+-------------------+     +-----------------------+     +---------------------+
| # successor       |     | + handleRequest()     |     | + handleRequest()   |
| + handleRequest() |     +-----------------------+     +---------------------+
| + setSuccessor()  |                                                     
+-------------------+

在这个UML图中，我们可以看到以下几个部分：

  1. Handler（抽象处理者）：定义了一个接口，用于规定具体处理者需要实现的方法。这些方法包括处理请求的方法（handleRequest）和设置后继处理者的方法（setSuccessor）。
  2. ConcreteHandler1、ConcreteHandler2（具体处理者）：实现了Handler接口，具体处理者在处理请求时可以根据需要决定是否处理请求。如果处理请求，则处理结束；如果不处理请求，则将请求传递给后继处理者。

模式定义与解释（Pattern Definition and Explanation）

职责链模式的主要目的是将请求的处理者组织成一条链，使得请求能够沿着链进行传递。这种设计可以降低处理对象之间的耦合，提高代码的可扩展性。职责链模式的特点如下：

  1. 灵活的请求处理：通过将请求处理对象组织成链式结构，我们可以灵活地调整处理对象的顺序。在处理请求时，处理对象可以根据需要决定是否处理请求，从而实现对请求的动态处理。
  2. 降低耦合：职责链模式将处理对象之间的关系解耦，使得每个处理对象只需要知道其后继处理者。这样一来，当我们需要修改或扩展处理对象时，无需修改其他处理对象的代码。
  3. 提高可扩展性：职责链模式允许我们在运行时动态地添加或修改处理对象。这样，在需要扩展系统功能时，我们可以直接添加新的处理对象，而无需修改现有的代码。
  4. 易于维护：职责链模式使得请求处理对象之间的关系更加清晰，有助于提高代码的可维护性。

职责链模式中的角色与组件（Roles and Components in Responsibility Chain Pattern）

请求（Request）

在职责链模式中，请求（Request）是一个关键组件。请求对象封装了客户端向处理者（Handler）发出的请求信息，包括请求的类型、具体内容以及其他相关数据。处理者将根据请求中的信息来决定是否处理该请求，或者将请求传递给链中的下一个处理者。请求对象可以用一个类或者一个结构体来实现。

例如，在一个请假审批系统中，员工请假的请求可以包含请假天数、请假原因等信息。我们可以创建一个LeaveRequest类来表示这个请求：

class LeaveRequest {
public:
    LeaveRequest(int days, const std::string& reason)
        : days(days), reason(reason) {}
    int getDays() const {
        return days;
    }
    const std::string& getReason() const {
        return reason;
    }
private:
    int days; // 请假天数
    std::string reason; // 请假原因
};

在这个例子中，LeaveRequest类封装了请假请求的信息。处理者可以根据请求中的天数来决定是否处理请求，或者将请求传递给链中的下一个处理者。通过创建一个请求对象，我们可以将请求信息与处理者解耦，从而实现更高的灵活性和可维护性。

处理者（Handler）

处理者（Handler）是职责链模式中的一个核心角色。处理者通常以一个抽象类或接口的形式实现，定义了处理请求的接口方法。处理者类通常包含一个指向链中下一个处理者的引用。处理者的子类（具体处理者）将实现该接口，以提供具体的请求处理逻辑。

下面是一个处理者基类的简单实现：

class Handler {
public:
    virtual ~Handler() = default;
    // 设置下一个处理者
    void setNextHandler(std::shared_ptr<Handler> nextHandler) {
        this->nextHandler = nextHandler;
    }
    // 处理请求
    virtual void handleRequest(const LeaveRequest& request) {
        if (nextHandler) {
            nextHandler->handleRequest(request);
        }
    }
protected:
    std::shared_ptr<Handler> nextHandler; // 链中的下一个处理者
};

在这个示例中，我们定义了一个Handler基类，其中包含了一个指向下一个处理者的nextHandler成员变量。setNextHandler()方法用于设置链中的下一个处理者。handleRequest()方法是一个虚函数，用于处理请求。在基类中，我们实现了默认的请求处理逻辑：如果存在下一个处理者，则将请求传递给下一个处理者。具体的处理者将覆盖该方法以提供具体的请求处理逻辑。

通过将处理者定义为抽象类或接口，我们可以实现对处理者的解耦，从而提高系统的灵活性和可维护性。处理者可以根据需要轻松地添加、删除或重新排列。

具体处理者（Concrete Handler）

具体处理者（Concrete Handler）是处理者（Handler）的具体子类，实现了抽象处理者中定义的处理请求接口方法。具体处理者负责处理请求，并根据请求的内容决定是否将请求传递给链中的下一个处理者。具体处理者可以根据不同的业务场景定制请求处理逻辑。

以请假审批系统为例，假设我们有三个层级的审批人：主管、经理和总监。不同层级的审批人可以审批不同天数的请假请求。我们可以创建三个具体处理者类来分别实现这三个层级的审批逻辑：

class Supervisor : public Handler {
public:
    void handleRequest(const LeaveRequest& request) override {
        if (request.getDays() <= 2) {
            std::cout << "Supervisor approved the leave request." << std::endl;
        } else if (nextHandler) {
            nextHandler->handleRequest(request);
        }
    }
};
class Manager : public Handler {
public:
    void handleRequest(const LeaveRequest& request) override {
        if (request.getDays() > 2 && request.getDays() <= 5) {
            std::cout << "Manager approved the leave request." << std::endl;
        } else if (nextHandler) {
            nextHandler->handleRequest(request);
        }
    }
};
class Director : public Handler {
public:
    void handleRequest(const LeaveRequest& request) override {
        if (request.getDays() > 5 && request.getDays() <= 30) {
            std::cout << "Director approved the leave request." << std::endl;
        } else if (nextHandler) {
            nextHandler->handleRequest(request);
        } else {
            std::cout << "The leave request is not approved." << std::endl;
        }
    }
};

在上面的代码中，我们创建了三个具体处理者类Supervisor、Manager和Director，分别表示主管、经理和总监。这些类都继承了Handler基类，并覆盖了handleRequest()方法，以实现不同层级审批人的请假审批逻辑。当请求的请假天数在审批人的审批范围内时，审批人会批准请求；否则，请求将被传递给链中的下一个处理者。

通过具体处理者类，我们可以根据实际业务需求灵活地实现不同的请求处理逻辑。职责链模式使得处理者之间的解耦成为可能，并允许我们轻松地添加、删除或修改处理者。

使用职责链模式

职责链模式在实际问题中的应用可以帮助我们更好地组织和管理代码，提高代码的灵活性和可维护性。下面我们将介绍一个使用职责链模式解决的实际问题：请假审批流程。

在很多公司，员工请假需要经过多级审批，例如主管、经理和总监。不同层级的审批人可以审批不同天数的请假请求。我们可以使用职责链模式来实现这个请假审批流程。首先，我们已经定义了LeaveRequest类来封装请假请求信息。接下来，我们创建了Handler基类以及表示不同层级审批人的具体处理者类：Supervisor、Manager和Director。

现在，我们可以创建一个简单的客户端程序来模拟请假审批流程：

int main() {
    // 创建处理者对象
    std::shared_ptr<Handler> supervisor = std::make_shared<Supervisor>();
    std::shared_ptr<Handler> manager = std::make_shared<Manager>();
    std::shared_ptr<Handler> director = std::make_shared<Director>();
    // 构建处理者链
    supervisor->setNextHandler(manager);
    manager->setNextHandler(director);
    // 创建请假请求
    LeaveRequest request1(2, "Personal errands");
    LeaveRequest request2(4, "Family vacation");
    LeaveRequest request3(15, "Long vacation");
    // 发送请求并处理
    supervisor->handleRequest(request1);
    supervisor->handleRequest(request2);
    supervisor->handleRequest(request3);
    return 0;
}

在上面的代码中，我们首先创建了表示主管、经理和总监的处理者对象。然后我们构建了处理者链，将主管、经理和总监连接起来。接着我们创建了三个不同天数的请假请求，并分别将这些请求发送给链中的第一个处理者（主管）进行处理。

运行这个程序，我们可以看到如下输出：

Supervisor approved the leave request.
Manager approved the leave request.
Director approved the leave request.

通过使用职责链模式，我们可以清晰地组织和管理请假审批流程。当需要添加新的审批层级或修改现有层级的审批逻辑时，我们只需要添加或修改相应的处理者类，而不需要修改其他部分的代码。这大大提高了代码的灵活性和可维护性。

示例：用职责链模式解决实际问题（Examples: Solving Real-World Problems with Responsibility Chain Pattern）

案例一：日志记录系统（Example 2: Logging System）

在许多应用程序中，日志记录系统是非常重要的，它可以帮助我们跟踪和调试代码。日志系统通常需要支持不同级别的日志记录，例如错误（Error）、警告（Warning）和信息（Info）。我们可以使用职责链模式来实现这个日志记录系统。

首先，我们需要定义一个LogMessage类来封装日志消息信息：

enum class LogLevel {
    Error, Warning, Info
};
class LogMessage {
public:
    LogMessage(LogLevel level, const std::string& message)
        : level(level), message(message) {}
    LogLevel getLevel() const {
        return level;
    }
    const std::string& getMessage() const {
        return message;
    }
private:
    LogLevel level; // 日志级别
    std::string message; // 日志消息
};

接下来，我们可以创建一个Logger基类，以及表示不同日志级别的具体处理者类：

class Logger : public Handler {
public:
    explicit Logger(LogLevel level) : level(level) {}
    void handleRequest(const LogMessage& request) override {
        if (request.getLevel() == level) {
            log(request.getMessage());
        } else if (nextHandler) {
            nextHandler->handleRequest(request);
        }
    }
protected:
    virtual void log(const std::string& message) = 0;
    LogLevel level;
};
class ErrorHandler : public Logger {
public:
    ErrorHandler() : Logger(LogLevel::Error) {}
protected:
    void log(const std::string& message) override {
        std::cerr << "Error: " << message << std::endl;
    }
};
class WarningHandler : public Logger {
public:
    WarningHandler() : Logger(LogLevel::Warning) {}
protected:
    void log(const std::string& message) override {
        std::cerr << "Warning: " << message << std::endl;
    }
};
class InfoHandler : public Logger {
public:
    InfoHandler() : Logger(LogLevel::Info) {}
protected:
    void log(const std::string& message) override {
        std::cout << "Info: " << message << std::endl;
    }
};

在这个例子中，我们创建了一个Logger基类，并定义了一个处理LogMessage请求的方法。然后我们创建了三个具体的处理者类ErrorHandler、WarningHandler和InfoHandler，分别用于处理不同级别的日志消息。

现在我们可以创建一个简单的客户端程序来模拟日志记录系统：

int main() {
    // 创建处理者对象
    std::shared_ptr<Handler> errorHandler = std::make_shared<ErrorHandler>();
    std::shared_ptr<Handler> warningHandler = std::make_shared<WarningHandler>();
    std::shared_ptr<Handler> infoHandler = std::make_shared<InfoHandler>();
    // 构建处理者链
    errorHandler->setNextHandler(warningHandler);
    warningHandler->setNextHandler(infoHandler);
    // 创建日志消息
    LogMessage errorLog(LogLevel::Error, "A runtime error occurred.");
    LogMessage warningLog(LogLevel::Warning, "An invalid input warning.");
    LogMessage infoLog(LogLevel::Info, "Application started.");
    // 记录日志
    errorHandler->handleRequest(errorLog);
    errorHandler->handleRequest(warningLog);
    errorHandler->handleRequest(infoLog);
    return 0;
}

在上面的客户端程序中，我们首先创建了表示错误处理器、警告处理器和信息处理器的处理者对象。然后我们构建了处理者链，将这三个处理器连接起来。接着我们创建了三个不同级别的日志消息，并将这些消息发送给链中的第一个处理者（错误处理器）进行处理。

运行这个程序，我们可以看到如下输出：

Error: A runtime error occurred.
Warning: An invalid input warning.
Info: Application started.

通过使用职责链模式，我们可以清晰地组织和管理日志记录系统。当需要添加新的日志级别或修改现有级别的日志处理逻辑时，我们只需要添加或修改相应的处理者类，而不需要修改其他部分的代码。这大大提高了代码的灵活性和可维护性。

总结，职责链模式为处理请求提供了一个非常灵活的框架，它使得多个处理者能够协同处理请求，并使得处理者之间的解耦成为可能。通过实际案例，我们可以看到职责链模式在实际问题中的应用能够帮助我们更好地组织和管理代码，提高代码的灵活性和可维护性。

案例二：购物优惠券折扣（Example 3: Shopping Coupons Discount）

在电商应用中，优惠券折扣是一个常见的功能。假设我们有不同类型的优惠券，例如满减券、折扣券和免运费券。当用户下订单时，我们需要计算应用优惠券后的实际支付金额。我们可以使用职责链模式来实现这个功能。

首先，我们需要定义一个Coupon类来封装优惠券信息：

enum class CouponType {
    FullReduction, Discount, FreeShipping
};
class Coupon {
public:
    Coupon(CouponType type, double value)
        : type(type), value(value) {}
    CouponType getType() const {
        return type;
    }
    double getValue() const {
        return value;
    }
private:
    CouponType type; // 优惠券类型
    double value; // 优惠券数值
};

接下来，我们可以创建一个CouponHandler基类，以及表示不同优惠券类型的具体处理者类：

class Order {
public:
    Order(double price, double shippingFee) 
        : price(price), shippingFee(shippingFee), finalPrice(price + shippingFee) {}
    double getFinalPrice() const {
        return finalPrice;
    }
    void setFinalPrice(double finalPrice) {
        this->finalPrice = finalPrice;
    }
    double getPrice() const {
        return price;
    }
    double getShippingFee() const {
        return shippingFee;
    }
private:
    double price; // 商品价格
    double shippingFee; // 运费
    double finalPrice; // 最终价格
};
class CouponHandler : public Handler {
public:
    void handleRequest(Order& order, const Coupon& coupon) override {
        if (canHandle(coupon)) {
            applyCoupon(order, coupon);
        } else if (nextHandler) {
            nextHandler->handleRequest(order, coupon);
        }
    }
protected:
    virtual bool canHandle(const Coupon& coupon) = 0;
    virtual void applyCoupon(Order& order, const Coupon& coupon) = 0;
};
class FullReductionHandler : public CouponHandler {
protected:
    bool canHandle(const Coupon& coupon) override {
        return coupon.getType() == CouponType::FullReduction;
    }
    void applyCoupon(Order& order, const Coupon& coupon) override {
        double finalPrice = order.getFinalPrice() - coupon.getValue();
        order.setFinalPrice(std::max(finalPrice, 0.0));
    }
};
class DiscountHandler : public CouponHandler {
protected:
    bool canHandle(const Coupon& coupon) override {
        return coupon.getType() == CouponType::Discount;
    }
    void applyCoupon(Order& order, const Coupon& coupon) override {
        double finalPrice = order.getFinalPrice() * coupon.getValue();
        order.setFinalPrice(finalPrice);
    }
};
class FreeShippingHandler : public CouponHandler {
protected:
    bool canHandle(const Coupon& coupon) override {
        return coupon.getType() == CouponType::FreeShipping;
    }
    void applyCoupon(Order& order, const Coupon& coupon) override {
        double finalPrice = order.getPrice();
        order.setFinalPrice(finalPrice);
    }
};

在这个例子中，我们创建了一个CouponHandler基类，并定义了一个处理Order和Coupon请求的方法。然后我们创建了三个具体的处理者类`FullRedReductionHandler、DiscountHandler和FreeShippingHandler`，分别用于处理满减券、折扣券和免运费券。

现在我们可以创建一个简单的客户端程序来模拟购物优惠券折扣系统：

int main() {
    // 创建处理者对象
    std::shared_ptr<Handler> fullReductionHandler = std::make_shared<FullReductionHandler>();
    std::shared_ptr<Handler> discountHandler = std::make_shared<DiscountHandler>();
    std::shared_ptr<Handler> freeShippingHandler = std::make_shared<FreeShippingHandler>();
    // 构建处理者链
    fullReductionHandler->setNextHandler(discountHandler);
    discountHandler->setNextHandler(freeShippingHandler);
    // 创建订单
    Order order(200, 20);
    // 创建优惠券
    Coupon fullReductionCoupon(CouponType::FullReduction, 50);
    Coupon discountCoupon(CouponType::Discount, 0.8);
    Coupon freeShippingCoupon(CouponType::FreeShipping, 0);
    // 应用优惠券
    fullReductionHandler->handleRequest(order, fullReductionCoupon);
    fullReductionHandler->handleRequest(order, discountCoupon);
    fullReductionHandler->handleRequest(order, freeShippingCoupon);
    // 输出最终价格
    std::cout << "Final price: " << order.getFinalPrice() << std::endl;
    return 0;
}

在这个客户端程序中，我们首先创建了表示满减处理器、折扣处理器和免运费处理器的处理者对象。然后我们构建了处理者链，将这三个处理器连接起来。接着我们创建了一个订单和三个不同类型的优惠券。将这些优惠券发送给链中的第一个处理者（满减处理器）进行处理。

运行这个程序，我们可以看到如下输出：

Final price: 120

通过使用职责链模式，我们可以清晰地组织和管理购物优惠券折扣系统。当需要添加新的优惠券类型或修改现有类型的优惠券处理逻辑时，我们只需要添加或修改相应的处理者类，而不需要修改其他部分的代码。这大大提高了代码的灵活性和可维护性。

总之，职责链模式在实际问题中的应用能够帮助我们更好地组织和管理代码，提高代码的灵活性和可维护性。在电商应用的购物优惠券折扣场景中，使用职责链模式实现优惠券折扣处理逻辑是一个非常实用的解决方案。

职责链模式的优缺点（Pros and Cons of Responsibility Chain Pattern）

优点（Pros）

在C++中使用职责链模式具有以下优点：

  1. 降低耦合性：职责链模式将处理请求的对象之间解耦，每个处理对象只需要知道其后继处理者。这使得处理对象可以独立地扩展和修改，而无需修改其他处理对象的代码。
  2. 灵活性增强：通过职责链模式，可以灵活地改变处理请求的对象顺序，这使得系统可以在运行时动态地调整责任链。此外，还可以根据需要添加或删除处理对象，以适应不同的业务场景。
  3. 提高可扩展性：职责链模式允许在运行时动态地添加或修改处理对象。这种特性使得在需要扩展系统功能时，可以直接添加新的处理对象，而无需修改现有的代码。
  4. 易于维护：职责链模式使得请求处理对象之间的关系更加清晰，有助于提高代码的可维护性。当需要修改或扩展某个处理对象时，只需关注该对象及其后继处理者，无需修改整个处理链。
  5. 更好地遵循单一职责原则：职责链模式将请求处理过程中的不同职责分散到多个处理对象中，每个处理对象只负责处理特定的请求。这有助于遵循单一职责原则，提高代码的可读性和可维护性。
  6. 动态处理：职责链模式使得请求处理过程具有动态性。处理对象可以根据请求的特征决定是否处理请求，如果不处理，则将请求传递给后继处理者。这种动态处理机制使得职责链模式能够适应不同的业务场景。

总之，C++中的职责链模式具有很多优点，包括降低耦合性、提高灵活性、易于维护、遵循单一职责原则等。这些优点使得职责链模式在处理复杂的请求处理场景时非常有用。

缺点（Cons）

尽管C++中的职责链模式具有诸多优点，但在使用过程中也存在一些潜在缺点：

  1. 性能问题：在职责链模式中，请求需要在处理对象链中逐个传递，直到找到合适的处理对象。如果链上的处理对象数量较多，请求处理过程可能会变得低效。因此，在性能要求较高的场景中，使用职责链模式可能导致性能下降。
  2. 链过长导致的调试困难：当责任链过长时，调试和维护可能变得困难。如果某个处理对象没有正确处理请求或者将请求传递给后继处理者，可能需要仔细检查链上的每个处理对象，才能找到问题所在。
  3. 设计复杂度：职责链模式需要为每个处理对象定义接口或抽象类，并实现具体的处理对象。此外，还需要组织处理对象的链式结构。相较于其他简单的设计模式，职责链模式的设计和实现复杂度较高。
  4. 请求无法处理的风险：如果责任链上没有合适的处理对象来处理某个请求，那么该请求将无法得到处理。在实际应用中，应确保链上的处理对象能够覆盖所有可能的请求类型，以避免请求无法处理的情况发生。
  5. 需要正确设置责任链：为了使职责链模式能够正确工作，需要正确地设置处理对象的链式关系。如果链式关系设置不当，可能导致某些请求得不到正确处理。因此，实际应用中需要谨慎地设置责任链，确保其能够正常工作。

综上所述，虽然职责链模式在C++中具有诸多优点，但在使用过程中也需要关注其潜在的缺点和挑战。在实际应用中，我们应权衡职责链模式的优缺点，根据具体需求和场景决定是否采用这种设计模式。

总结（Conclusion）

从心理学的角度来看，C++中的职责链模式可以帮助程序员更好地应对代码维护和扩展的挑战。本文介绍了职责链模式的优点和缺点，希望读者能够从中受益，并在实际项目中做出明智的设计决策。

职责链模式遵循单一职责原则，将处理请求的职责分散到多个处理对象中，使得代码更具可读性和可维护性。这种分散式的设计可以减轻程序员的心理负担，提高编程效率。同时，职责链模式的灵活性使得程序员可以根据需求轻松地调整处理对象的顺序，降低了代码修改过程中的心理压力。

然而，职责链模式也存在一定的缺点，如性能问题、链过长导致的调试困难等。在实际项目中，程序员需要根据具体情况权衡职责链模式的优缺点，以找到最适合项目需求的解决方案。

总之，本文从心理学角度为您讲解了C++职责链模式的相关知识，希望能够帮助您在面对复杂的编程问题时，更加从容地做出决策。在今后的学习和实践中，我们鼓励您多尝试不同的设计模式，从而提高自己的编程能力和心理素质，迈向更高的编程境界。

文章标签：
日志服务
C++
程序员
设计模式
uml
数据处理
关键词：
C++解耦
C++职责链模式
相关实践学习
日志服务之数据清洗与入湖
本教程介绍如何使用日志服务接入NGINX模拟数据，通过数据加工对数据进行清洗并归档至OSS中进行存储。
泡沫o0
目录
相关文章
泡沫o0
|
2月前
|
算法 测试技术 数据处理
【C++ 设计思路】优化C++项目：高效解耦库接口的实战指南
【C++ 设计思路】优化C++项目：高效解耦库接口的实战指南
泡沫o0
98 5
泡沫o0
|
2月前
|
设计模式 API 数据库
【C/C++ 设计思路】C++中解耦策略的艺术：有效管理复杂依赖关系
【C/C++ 设计思路】C++中解耦策略的艺术：有效管理复杂依赖关系
泡沫o0
88 3
潘志闻
|
C++
C++职责链模式
简述 职责链模式（Chain of Responsibility Pattern）使多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合关系。
潘志闻
1240 0
ForcibleBugMaker
|
4天前
|
C++
【C++】日期类Date（详解）②
- `-=`通过复用`+=`实现，`Date operator-(int day)`则通过创建副本并调用`-=`。 - 前置`++`和后置`++`同样使用重载，类似地，前置`--`和后置`--`也复用了`+=`和`-=1`。 - 比较运算符重载如`&gt;`, `==`, `&lt;`, `&lt;=`, `!=`，通常只需实现两个，其他可通过复合逻辑得出。 - `Date`减`Date`返回天数，通过迭代较小日期直到与较大日期相等，记录步数和符号。 ``` 这是236个字符的摘要，符合240字符以内的要求，涵盖了日期类中运算符重载的主要实现。
ForcibleBugMaker
11 4
米诺斯
|
7天前
|
C++
C++职工管理系统（类继承、文件、指针操作、中文乱码解决）
C++职工管理系统（类继承、文件、指针操作、中文乱码解决）
米诺斯
10 0
C++职工管理系统（类继承、文件、指针操作、中文乱码解决）
东洛的克莱斯韦克
|
1天前
|
编译器 C语言 C++
【C++】详解string类
【C++】详解string类
东洛的克莱斯韦克
7 0
东洛的克莱斯韦克
|
1天前
|
编译器 C++
【C++】详解初始化列表，隐式类型转化，类静态成员，友元
【C++】详解初始化列表，隐式类型转化，类静态成员，友元
东洛的克莱斯韦克
6 0
ForcibleBugMaker
|
4天前
|
存储 编译器 C++
【C++】类和对象④（再谈构造函数：初始化列表，隐式类型转换，缺省值
C++中的隐式类型转换在变量赋值和函数调用中常见，如`double`转`int`。取引用时，须用`const`以防修改临时变量，如`const int& b = a;`。类可以有隐式单参构造，使`A aa2 = 1;`合法，但`explicit`关键字可阻止这种转换。C++11起，成员变量可设默认值，如`int _b1 = 1;`。博客探讨构造函数、初始化列表及编译器优化，关注更多C++特性。
ForcibleBugMaker
9 0
ForcibleBugMaker
|
4天前
|
编译器 C++
【C++】类和对象④（类的默认成员函数：取地址及const取地址重载 ）
本文探讨了C++中类的成员函数，特别是取地址及const取地址操作符重载，通常无需重载，但展示了如何自定义以适应特定需求。接着讨论了构造函数的重要性，尤其是使用初始化列表来高效地初始化类的成员，包括对象成员、引用和const成员。初始化列表确保在对象创建时正确赋值，并遵循特定的执行顺序。
ForcibleBugMaker
6 0
ForcibleBugMaker
|
4天前
|
C语言 C++
【C++】日期类Date（详解）③
该文介绍了C++中直接相减法计算两个日期之间差值的方法，包括确定max和min、按年计算天数、日期矫正及计算差值。同时，文章讲解了const成员函数，用于不修改类成员的函数，并给出了`GetMonthDay`和`CheckDate`的const版本。此外，讨论了流插入和流提取的重载，需在类外部定义以符合内置类型输入输出习惯，并介绍了友元机制，允许非成员函数访问类的私有成员。全文旨在深化对运算符重载、const成员和流操作的理解。
ForcibleBugMaker
7 0