C++ Best Practices: Serialization and Abstract Classes without library access

The question is a little open, so I'll just give my preferred (and so far successful) way of implementing serialization/deserialization, along with the reasons why I like it. The idea is heavily inspired by how fmt (now std::format) does formatters.

Looking at serialize first:

// The customization point to add serializer implementations for your custom structs
template<typename T>
struct Serializer;

// Example: Serialization for integral types
template<std::integral Integer>
struct Serializer<Integer> {
    auto operator()(Integer value, auto out) const {
        // If you need certain endianness, take care of that here
        return std::copy_n(reinterpret_cast<const std::byte*>(&value), sizeof(value), out);
    }
};

// Returns the iterator past the last written byte
template<typename T, std::output_iterator<std::byte> Iterator>
Iterator serialize(const T& value, Iterator target) {
    return Serializer<T>{}(value, target);
}
// Helper overload that returns a vector, but can be more generalized to support other containers
template<typename T>
std::vector<std::byte> serialize(const T& value) {
    std::vector<std::byte> bytes{};
    serialize(value, std::back_inserter(bytes));
    return bytes;
}

Implementing a serializer for your own struct:

// MyType.hpp contains:

// ... your struct
struct MyType {
    int number;
    long long bignumber;
};

// ... and then its serializer, so you always have it available
template<>
struct Serializer<MyType> {
    auto operator()(const MyType& value, auto out) const {
        out = serialize(value.number, out);
        return serialize(value.bignumber, out);
    }
}

The plan for deserialize is similar. I went for contiguous_iterator in the following code, because I realized you probably don't need your serialization to work for non-contiguous containers.

template<typename T>
struct Deserializer;

template<std::integral Integer>
struct Deserializer<Integer> {
    template<std::contiguous_iterator Iterator, std::sized_sentinel_for<Iterator> Sentinel>
    auto operator()(Iterator begin, Sentinel end) const {
        if ((end - begin) < sizeof(Integer)) {
            throw std::runtime_error{"not enough data"};
        }
        Integer value;
        std::memcpy(&value, std::to_address(begin), sizeof(Integer));
        // You'll need certain endianness; if native != desired you'll need to byteswap
        return std::make_pair(value, begin + sizeof(Integer));
    }
};

template<typename T, std::contiguous_iterator Iterator, std::sized_sentinel_for<Iterator> Sentinel>
std::pair<T, Iterator> deserialize(Iterator begin, Sentinel end) {
    return Deserializer<T>{}(begin, end);
}
// Helper taking a range, guarantees all bytes are parsed, otherwise throws
template<typename T, std::ranges::contiguous_range Range>
T deserialize(const Range& range) {
    auto [value, pos] = deserialize(std::begin(range), std::end(range));
    if (pos != std::end(range) throw std::runtime_error{"Not all bytes were deserialized"};
    // move the returnvalue, because it's a structured binding
    // not sure this is still necessary in newer standards?
    return std::move(value);
}

Usage

MyRequest request{...};

// Creates a vector, which is not the most efficient thing
udpSocket.send(serialize(request));

// Alternatively: serialize to a buffer if the size is known ahead of time
// This can easily be made into a helper method alongside serialize
std::array<std::byte, sizeof(MyRequest)> buffer;
serialize(request, buffer.begin());
udpSocket.send(serialize(request));

// complexities of UDP are not part of this sample, just assume we received a full response struct...
auto bytes = udpSocket.receive();

auto response = deserialize<MyResponse>(bytes);

// here we know response was successfully parsed and used all input bytes

Advantages

• Can add (de)serialization for any type, even ones you don't control (std::string, int, ...)
• Can implement only the direction you need; no need to implement serialization for a type you only deserialize and vice versa
• Can keep the types very simple - no virtual dtors etc
• Composable; for example serialization of complex types can be implemented by calling serialize with simple types that it's made up of
• Extra helper overloads of serialize/deserialize can easily be added as long as they're somehow implementable with iterators
• Extra features, like sizes known at compile time, can be implemented to conditionally optimize implementations of serialize/deserialize for types that support them