在C++中实现受限类型擦除：阻止不同底层类型赋值

首先明确核心限制：在纯类型擦除（单个非模板TypeErased类）的设计下，编译时无法直接阻止不同底层类型的赋值——因为编译时所有TypeErased实例都是同一类型，编译器无法感知它们的底层类型差异。

如果坚持要编译时检查，只能调整设计、放弃部分类型擦除的灵活性（比如将TypeErased做成模板类，让不同底层类型对应不同模板实例），但这种设计无法将不同底层类型的实例统一存储（除非通过基类指针，但赋值时仍需运行时检查）。

如果要保留纯类型擦除的特性，同时实现类型安全的赋值，最优雅的模板化方案是通过运行时类型检查配合异常机制（而非粗暴的RTTI+assert），具体实现如下：

修改后的Concept-Model框架 #

#include <memory>
#include <stdexcept>
#include <iostream>

class TypeErased
{
public:
    template<typename T>
    TypeErased(T value)
        : p_impl(std::make_unique<Model<T>>(std::move(value)))
    {
    }

    TypeErased(const TypeErased& other)
        : p_impl(other.p_impl->clone())
    {
    }

    TypeErased(TypeErased&& other) noexcept = default;

    TypeErased& operator=(const TypeErased& other)
    {
        if (this != &other) {
            p_impl = other.p_impl->assign(*other.p_impl);
        }
        return *this;
    }

    TypeErased& operator=(TypeErased&& other) noexcept = default;

    ~TypeErased() = default;

    // 示例：暴露底层操作接口
    void do_something()
    {
        p_impl->do_something();
    }

private:
    struct Concept
    {
        virtual ~Concept() = default;
        virtual std::unique_ptr<Concept> clone() const = 0;
        virtual std::unique_ptr<Concept> assign(const Concept& other) const = 0;
        virtual void do_something() = 0;
    };

    template<typename T>
    struct Model : Concept
    {
        Model(T value) : data(std::move(value)) {}

        std::unique_ptr<Concept> clone() const override
        {
            return std::make_unique<Model<T>>(*this);
        }

        std::unique_ptr<Concept> assign(const Concept& other) const override
        {
            // 尝试将源对象转换为同类型的Model<T>
            if (const auto* other_model = dynamic_cast<const Model<T>*>(&other)) {
                return std::make_unique<Model<T>>(*other_model);
            }
            // 类型不匹配时抛出标准异常，替代运行时断言
            throw std::bad_cast{};
        }

        void do_something() override
        {
            // 针对T的具体实现，示例为打印数据
            std::cout << data << std::endl;
        }

        T data;
    };

    std::unique_ptr<Concept> p_impl;
};

实现说明 #

1. 类型安全保障：在Model<T>::assign中通过dynamic_cast检查源对象的底层类型，仅当类型匹配时才完成赋值，否则抛出std::bad_cast异常（可自定义异常类型增强可读性）。
2. 模板化封装：所有类型相关逻辑都封装在Model<T>模板中，严格遵循Concept-Model范式，避免代码冗余。
3. 保留类型擦除特性：仍可使用单个TypeErased类型存储任意底层类型的对象，同时避免了跨类型赋值的不安全操作。

如果必须追求编译时检查，只能改用模板化的TypeErased<T>设计，但这会牺牲类型擦除的核心优势——统一类型存储的能力。

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