Сериализация для разных абстрактных классов с множеством наследников

Как записать и прочесть наследников разных абстрактных классов?

#include <iostream>
#include <fstream>
#include <vector>
#include <cassert>

// ============================================================================
//  Bases
// ----------------------------------------------------------------------------
class Base1 {
public:
    virtual void func1() = 0;
};
class Base2 {
public:
    virtual void func2() = 0;
};
class Base3 {
public:
    virtual void func3() = 0;
};

// ============================================================================
//  Derived
// ----------------------------------------------------------------------------
class Derived11 : public Base1 {
public:
    void func1() override {
        std::cout << 11 << std::endl;
    }
};
class Derived12 : public Base1 {
public:
    void func1() override {
        std::cout << 12 << std::endl;
    }
};

class Derived21 : public Base2 {
public:
    void func2() override {
        std::cout << 21 << std::endl;
    }
};
class Derived22 : public Base2 {
public:
    void func2() override {
        std::cout << 22 << std::endl;
    }
};

class Derived31 : public Base3 {
public:
    void func3() override {
        std::cout << 31 << std::endl;
    }
};
class Derived32 : public Base3 {
public:
    void func3() override {
        std::cout << 32 << std::endl;
    }
};

// ============================================================================
//  Serialization
// ----------------------------------------------------------------------------
template <typename _Ty>
void Write(std::ostream& Stream, _Ty Container) {
    size_t Size = Container.size();
    Stream.write(reinterpret_cast<const char*>(&Size), sizeof(Size));

    if (Size > 0)
        for (auto Value : Container)
            Stream.write(reinterpret_cast<const char*>(&Value), sizeof(Value));
}
template <typename _Ty>
void Read(std::istream& Stream, _Ty& Container) {
    size_t Size;
    Stream.read(reinterpret_cast<char*>(&Size), sizeof(Size));

    Container.clear();
    for (size_t i = 0; i < Size; ++i) {
        typename _Ty::value_type Value = { }; // Value - is nullptr
        Stream.read(reinterpret_cast<char*>(&Value), sizeof(Value));
        Container.push_back(Value);
    }
}

// ============================================================================
//  Main
// ----------------------------------------------------------------------------
int main() {
    std::vector<Base1*> Vector1;
    Vector1.push_back(new Derived11);
    Vector1.push_back(new Derived12);

    std::vector<Base2*> Vector2;
    Vector2.push_back(new Derived21);
    Vector2.push_back(new Derived22);

    std::vector<Base3*> Vector3;
    Vector3.push_back(new Derived31);
    Vector3.push_back(new Derived32);

    // Write
    std::fstream File("file.a", std::ios::out);
    assert(File.is_open());
    Write(File, Vector1);
    Write(File, Vector2);
    Write(File, Vector3);
    File.close();

// 
//  ...
// 

    // Read
    File.open("file.a", std::ios::in);
    assert(File.is_open());
    Read(File, Vector1);
    Read(File, Vector2);
    Read(File, Vector3);
    File.close();
    return 0;
}