如何避免具有aligned_storage和多态性的未定义行为

不确定是否需要reinterpret_cast使用基类类型的确切语义，但您始终可以这样做，

typename std::aligned_storage<sizeof(Derived), alignof(Derived)>::type storage;
auto derived_ptr = new (&storage) Derived{};
auto base_ptr = static_cast<Base*>(derived_ptr);
std::cout << base_ptr->forward() << std::endl;

另外，为什么要在代码中使用带有base引用的auto&&？

如果您只知道代码中基类的类型，请考虑在抽象中使用简单的特征aligned_storage

template <typename Type>
struct TypeAwareAlignedStorage {
using value_type = Type;
using type = std::aligned_storage_t<sizeof(Type), alignof(Type)>;
};

然后，您现在可以使用存储对象来获取它所表示的类型

template <typename StorageType>
void cast_to_base(StorageType& storage) {
using DerivedType = std::decay_t<StorageType>::value_type;
auto& derived_ref = *(reinterpret_cast<DerivedType*>(&storage));
Base& base_ref = derived_ref;
base_ref.forward();
}

如果您希望它与完美的转发一起使用，请使用简单的转发特征

namespace detail {
template <typename TypeToMatch, typename Type>
struct MatchReferenceImpl;
template <typename TypeToMatch, typename Type>
struct MatchReferenceImpl<TypeToMatch&, Type> {
using type = Type&;
};
template <typename TypeToMatch, typename Type>
struct MatchReferenceImpl<const TypeToMatch&, Type> {
using type = const Type&;
};
template <typename TypeToMatch, typename Type>
struct MatchReferenceImpl<TypeToMatch&&, Type> {
using type = Type&&;
};
template <typename TypeToMatch, typename Type>
struct MatchReferenceImpl<const TypeToMatch&&, Type> {
using type = const Type&&;
};
}
template <typename TypeToMatch, typename Type>
struct MatchReference {
using type = typename detail::MatchReferenceImpl<TypeToMatch, Type>::type;
};
template <typename StorageType>
void cast_to_base(StorageType&& storage) {
using DerivedType = std::decay_t<StorageType>::value_type;
auto& derived_ref = *(reinterpret_cast<DerivedType*>(&storage));
typename MatchReference<StorageType&&, Base>::type base_ref = derived_ref;
std::forward<decltype(base_ref)>(base_ref).forward();
}

如果使用类型擦除来创建派生类类型，然后将其添加到同构容器中，则可以执行以下操作

struct Base {
public:
virtual ~Base() = default;
virtual int forward() = 0;
};
/**
* An abstract base mixin that forces definition of a type erasure utility
*/
template <typename Base>
struct GetBasePtr {
public:
Base* get_base_ptr() = 0;
};
template <DerivedType>
class DerivedWrapper : public GetBasePtr<Base> {
public:
// assert that the derived type is actually a derived type
static_assert(std::is_base_of<Base, std::decay_t<DerivedType>>::value, "");
// forward the instance to the internal storage
template <typename T>
DerivedWrapper(T&& storage_in)  { 
new (&this->storage) DerivedType{std::forward<T>(storage_in)};
}
Base* get_base_ptr() override {
return reinterpret_cast<DerivedType*>(&this->storage);
}
private:
std::aligned_storage_t<sizeof(DerivedType), alignof(DerivedType)> storage;
};
// the homogenous container, global for explanation purposes
std::unordered_map<IdType, std::unique_ptr<GetBasePtr<Base>>> homogenous_container;
template <typename DerivedType>
void add_to_homogenous_collection(IdType id, DerivedType&& object) {
using ToBeErased = DerivedWrapper<std::decay_t<DerivedType>>;
auto ptr = std::unique_ptr<GetBasePtr<Base>>{
std::make_unique<ToBeErased>(std::forward<DerivedType>(object))};
homogenous_container.insert(std::make_pair(id, std::move(ptr)));
}
// and then
homogenous_container[id]->get_base_ptr()->forward();

你可以简单地做

auto* derived = new (&storage) Derived{};
Base* base = derived;

所以没有reinterpret_cast.

在你拥有的"简单"示例中，由于您是从派生转换为基，因此static_cast或dynamic_cast都可以。

更复杂的用例将以眼泪告终，因为基指针和指向同一对象的派生指针的基础值不必相等。它可能今天有效，但明天失败：

1. reinterpret_cast不能很好地处理继承，尤其是多重继承。如果要从多个基类继承，并且第一个基类具有大小(如果未执行空基优化，则没有大小)，则从不相关的类型reinterpret_cast第二个基类将不会应用偏移量。
2. 重载不能很好地与覆盖配合使用。模板化类不应具有虚拟方法。具有虚拟方法的模板化类不应与过多的类型推导一起使用。
3. 未定义的行为对于在C++中指定 MI 的方式至关重要，并且是不可避免的，因为您正在尝试获取(在编译时)故意擦除的内容(在编译时)。只需从该类中删除每个virtual关键字并使用模板实现所有内容，一切都会变得更加简单和正确。
4. 您确定派生类对象可以容纳 16 个字节吗？您可能需要一些static_assert。
5. 如果您愿意承受虚拟函数带来的性能损失，为什么要关心对齐呢？