将NonTypedData实例向下转型为TypedData是否属于未定义行为？

一、核心结论：这种转型属于未定义行为 #

C++中，向下转型（将基类指针/引用转换为子类类型）仅当基类对象实际是子类类型的实例时才合法。如果基类对象本身并非子类实例，强行转型后：

• 即使子类是空接口（无数据成员），编译器仍可能为其生成虚表相关结构（若包含虚函数），而基类对象的内存布局中没有这些信息，访问转型后的对象会导致内存越界、虚表调用错误等未定义行为。
• 若子类非虚继承，转型后的指针偏移会完全错误，直接触发非法内存访问。

你的直觉是对的，这种写法绝对不能用。

二、无模板存储算术类型的合法实现方案 #

针对你“无模板存储任意算术类型数据”的需求，以下是几种完全符合C++标准的实现方式：

方案1：TypedData作为视图类持有NonTypedData引用 #

这正是你提到的思路，通过视图类封装类型安全的访问逻辑，而非继承关系：

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

// 无模板的底层存储类
class NonTypedData {
private:
    std::unique_ptr<void, void(*)(void*)> data_;
    const std::type_info& type_;

public:
    template<typename T>
    NonTypedData(T value) 
        : data_(new T(value), [](void* p){ delete static_cast<T*>(p); }),
          type_(typeid(T)) {
        static_assert(std::is_arithmetic_v<T>, "仅支持算术类型");
    }

    // 支持移动语义
    NonTypedData(NonTypedData&&) noexcept = default;
    NonTypedData& operator=(NonTypedData&&) noexcept = default;

    // 禁止拷贝（如需拷贝可添加类型匹配的拷贝构造）
    NonTypedData(const NonTypedData&) = delete;
    NonTypedData& operator=(const NonTypedData&) = delete;

    // 获取类型信息与原始指针
    const std::type_info& get_type() const { return type_; }
    void* get_raw() { return data_.get(); }
    const void* get_raw() const { return data_.get(); }
};

// 类型安全的视图类，仅负责访问
template<typename T>
class TypedData {
private:
    NonTypedData& data_;

public:
    explicit TypedData(NonTypedData& data) : data_(data) {
        if (data_.get_type() != typeid(T)) {
            throw std::bad_cast();
        }
        static_assert(std::is_arithmetic_v<T>, "仅支持算术类型");
    }

    T get() const {
        return *static_cast<const T*>(data_.get_raw());
    }

    void set(T value) {
        *static_cast<T*>(data_.get_raw()) = value;
    }
};

// 使用示例
int main() {
    NonTypedData int_data(42);
    NonTypedData float_data(3.14f);

    // 合法访问
    TypedData<int> int_view(int_data);
    std::cout << int_view.get() << "\n"; // 输出42
    int_view.set(100);
    std::cout << int_view.get() << "\n"; // 输出100

    // 类型不匹配会抛出异常
    try {
        TypedData<float> wrong_view(int_data);
    } catch (const std::bad_cast& e) {
        std::cout << "类型转换失败: " << e.what() << "\n";
    }

    return 0;
}

方案2：直接使用std::any（最简洁的标准库方案） #

std::any本身就是无模板的通用存储容器，支持任意类型，且内置类型安全检查：

#include <any>
#include <stdexcept>
#include <iostream>

int main() {
    std::any int_data = 42;
    std::any float_data = 3.14f;

    // 安全读取与修改
    if (int_data.type() == typeid(int)) {
        std::cout << std::any_cast<int>(int_data) << "\n";
        std::any_cast<int&>(int_data) = 100;
        std::cout << std::any_cast<int>(int_data) << "\n";
    }

    // 错误转换会抛出异常
    try {
        std::any_cast<float>(int_data);
    } catch (const std::bad_any_cast& e) {
        std::cout << "类型转换失败: " << e.what() << "\n";
    }

    return 0;
}

这种方式无需自己实现存储逻辑，完全依赖标准库，代码简洁且无任何未定义行为。

方案3：使用std::variant（已知类型范围时的高性能选择） #

如果能预先枚举所有需要支持的算术类型，std::variant是更高效的选择——编译时类型检查，无运行时类型ID开销：

#include <variant>
#include <iostream>
#include <string>

// 枚举所有支持的算术类型
using ArithmeticData = std::variant<int, float, double, long long, unsigned int>;

int main() {
    ArithmeticData data = 42;
    ArithmeticData float_data = 3.14;

    // 通用访问（使用std::visit）
    std::visit([](auto&& val) {
        std::cout << "值: " << val << "\n";
    }, data);

    // 类型匹配时修改
    if (std::holds_alternative<int>(data)) {
        std::get<int>(data) = 100;
        std::cout << "修改后的值: " << std::get<int>(data) << "\n";
    }

    return 0;
}

总结 #

• 绝对不要尝试将基类实例向下转型为未实际继承的子类，这是明确的未定义行为。
• 推荐的合法实现优先级：std::any（灵活）> 视图类（自定义可控）> std::variant（高性能）。

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