C++中如何阻止Entity派生类的构造与析构函数被直接调用？

一、基于计数的警告方案的潜在漏洞 #

你这套计数方案可能存在几个容易遗漏的点：

• 线程安全问题：多线程环境下，如果Spawn/Destroy和手动构造同时操作计数，很容易出现竞态，导致警告误触发或者完全没反应。
• 拷贝/移动构造绕开检查：要是派生类支持拷贝或移动，用户可以拿一个合法创建的实例拷贝出全新的对象，这时候计数根本不会被Spawn函数更新，直接绕开你的检查逻辑。
• 静态实例绕过：比如有人在函数里定义static DerivedEntity e;，这种静态实例的构造是程序启动或首次调用函数时自动执行的，完全走不到Spawn流程，计数追踪不到。
• 析构时机误判：要是用户手动调用析构函数（C++语法允许，虽然不推荐），Destroy的计数减少和手动析构的时机对不上，要么警告错发，要么对象被多次析构（先手动析构再调用Destroy）。

二、实现运行期抛异常或编译期阻止的可行方案 #

1. 运行期抛异常：覆盖绝大多数误用场景 #

你可以在基类里加一个受保护的标志位，只有Spawn函数能把它设为合法状态，派生类构造时检查这个标志，非法就抛异常：

#include <stdexcept>

class Entity {
protected:
    bool m_isSpawned = false;
    friend class EntityFactory; // 给工厂开权限修改标志
    Entity() = default; // 基类默认构造

public:
    virtual ~Entity() {
        if (!m_isSpawned) {
            throw std::runtime_error("禁止手动调用析构！请使用EntityFactory::Destroy");
        }
        m_isSpawned = false;
    }

    // 直接禁用拷贝移动，堵死绕路的可能
    Entity(const Entity&) = delete;
    Entity& operator=(const Entity&) = delete;
    Entity(Entity&&) = delete;
    Entity& operator=(Entity&&) = delete;
};

class EntityFactory {
public:
    template<typename T, typename... Args>
    static T* SpawnEntity(Args&&... args) {
        static_assert(std::is_base_of_v<Entity, T>, "T必须是Entity的派生类");
        T* entity = new T(std::forward<Args>(args)...);
        entity->m_isSpawned = true; // 标记为合法创建
        return entity;
    }

    static void Destroy(Entity* entity) {
        if (entity && entity->m_isSpawned) {
            delete entity; // 此时m_isSpawned为true，析构不会抛异常
        } else {
            throw std::runtime_error("要销毁的对象无效，或是手动创建的非法实例！");
        }
    }
};

// 派生类示例
class DerivedEntity : public Entity {
public:
    DerivedEntity() {
        if (!m_isSpawned) {
            throw std::runtime_error("禁止手动构造！请使用EntityFactory::SpawnEntity");
        }
    }
};

• 核心点：禁用拷贝移动防止绕路；派生类构造时强制检查标志；工厂负责设置合法状态。
• 补充优化：要是怕派生类忘了加构造检查，可以把基类构造改成带参数的形式，比如explicit Entity(bool spawned) : m_isSpawned(spawned) {}，工厂创建时传true，用户手动创建只能传false，此时基类或派生类构造直接抛异常，强制派生类必须配合规则。

2. 编译期阻止：最安全但有约束 #

如果能要求所有派生类使用CRTP（奇异递归模板模式）继承，就能在编译期直接阻止手动构造：

// 底层基类，只有工厂能访问构造
class EntityBase {
protected:
    EntityBase() = default;
    friend class EntityFactory;
};

// CRTP基类，把构造设为私有，只有工厂能创建实例
template<typename Derived>
class Entity : public EntityBase {
private:
    Entity() = default;
    friend class EntityFactory;

public:
    virtual ~Entity() = default;

    // 同样禁用拷贝移动
    Entity(const Entity&) = delete;
    Entity& operator=(const Entity&) = delete;
    Entity(Entity&&) = delete;
    Entity& operator=(Entity&&) = delete;
};

class EntityFactory {
public:
    template<typename T, typename... Args>
    static T* SpawnEntity(Args&&... args) {
        static_assert(std::is_base_of_v<Entity<T>, T>, "T必须继承Entity<T>");
        return new T(std::forward<Args>(args)...); // 工厂是友元，能访问私有构造
    }

    static void Destroy(EntityBase* entity) {
        delete static_cast<EntityBase*>(entity);
    }
};

// 派生类必须按此规则编写，否则编译报错
class DerivedEntity : public Entity<DerivedEntity> {
    // 派生类构造可以是公有的，但基类构造私有，用户根本无法直接创建实例
};

• 局限性：必须要求所有派生类按这个规则实现，要是你控制不了所有派生类的写法，这个方案就用不了。但如果能约束团队代码规范，这是从根源上杜绝手动构造的最安全方式。

3. 编译警告+运行检查的折中方案 #

要是没法强制派生类用CRTP，可以给基类的构造析构加[[deprecated]]属性，编译器会弹出警告提醒开发者规范使用：

class Entity {
protected:
    Entity() [[deprecated("禁止手动构造！请使用EntityFactory::SpawnEntity")]] = default;

public:
    virtual ~Entity() [[deprecated("禁止手动析构！请使用EntityFactory::Destroy")]] = default;

    // 禁用拷贝移动
    Entity(const Entity&) = delete;
    Entity& operator=(const Entity&) = delete;
    Entity(Entity&&) = delete;
    Entity& operator=(Entity&&) = delete;
};

• 效果：用户手动构造时编译器会弹出警告，但不会阻止编译，适合用来规范团队开发的代码风格。

三、总结 #

• 如果你完全控制不了派生类的实现，运行期检查+禁用拷贝移动是最靠谱的方案，虽然没法100%阻止恶意绕过，但能覆盖绝大多数误用场景，而且非法调用时会抛出明确的异常提示。
• 你的计数方案需要补充线程安全处理，还要补上拷贝构造、静态实例这些场景的检查，不然会存在漏洞。
• 要是能约束派生类的写法，CRTP的编译期阻止方案是最优解，从根源上杜绝手动构造的可能。

内容的提问来源于stack exchange，提问作者Bruno Jácôme