C++抽象类是否需要遵循五法则？是否需实现特殊成员函数？

Great question! Let’s unpack this step by step. First, let’s recap your base class:

class Base {
public:
    virtual ~Base() = default;
    virtual void foo() = 0;
};

Short Answer #

No, you’re not required to follow the Rule of Five for this pure virtual base class. Since Base can’t be instantiated directly, the default-generated copy/move special members (if left as-is) won’t be called directly. But there are specific scenarios where you should explicitly define or delete these functions—let’s cover those cases.

When You Don’t Need to Do Anything #

If your pure virtual base class has no data members, and you don’t want to restrict how derived classes handle copy/move operations, you can safely rely on the compiler-generated default special members. These defaults are public, but since you can’t create a Base object, they’ll only ever be invoked indirectly by derived classes (if the derived class uses them).

Scenarios Where You Should Define/Delete Special Members #

1. You Want to Prohibit Copy/Move for All Derived Classes

If your interface represents a non-copyable/non-movable resource (like a network connection, file handle, or unique service), it’s a best practice to explicitly delete the copy and move operations in the base class. This ensures all derived classes inherit this restriction by default—preventing accidental copy/move behavior that violates your design intent.

Example:

class Base {
public:
    virtual ~Base() = default;
    virtual void foo() = 0;

    // Delete copy operations
    Base(const Base&) = delete;
    Base& operator=(const Base&) = delete;

    // Delete move operations
    Base(Base&&) = delete;
    Base& operator=(Base&&) = delete;
};

Derived classes would now have to explicitly re-enable these operations (if needed) by defining their own versions.

2. The Base Class Has Data Members That Need Custom Copy/Move Logic

While pure virtual base classes are usually focused on interface (not state), it’s possible to have data members in them. If those members require custom copy or move behavior (instead of the default bitwise copy), you’ll need to explicitly define the corresponding special members.

Example:

class Base {
public:
    virtual ~Base() = default;
    virtual void foo() = 0;

    // Base class has state that needs custom handling
    std::unique_ptr<SomeResource> resource;

    // Custom copy constructor (note: unique_ptr can't be copied, so this is just an example)
    Base(const Base& other) : resource(std::make_unique<SomeResource>(*other.resource)) {}

    Base& operator=(const Base& other) {
        if (this != &other) {
            resource = std::make_unique<SomeResource>(*other.resource);
        }
        return *this;
    }

    // Custom move constructor
    Base(Base&& other) noexcept : resource(std::move(other.resource)) {}

    Base& operator=(Base&& other) noexcept {
        if (this != &other) {
            resource = std::move(other.resource);
        }
        return *this;
    }
};

This ensures that when a derived class is copied/moved, the base class’s state is handled correctly according to your requirements.

Final Takeaway #

• For interface-only pure virtual base classes with no state, the default special members are fine—no need to explicitly declare them.
• If you need to enforce non-copyable/non-movable behavior across all derived classes, delete the copy/move operations in the base.
• If the base has state requiring custom copy/move logic, implement those special members explicitly.

内容的提问来源于stack exchange，提问作者Markus Rothe