如何在编译时判断类型是否可序列化（基于自定义序列化框架）

Absolutely, this is totally feasible using SFINAE (Substitution Failure Is Not An Error) — the go-to technique for compile-time type validation in C++. You don’t need to manually write is_serializable for every type; we can build an automatic, clean solution that detects whether valid Read and Write functions exist for a given type. Let’s walk through the implementations.

1. Checking for Free Read/Write Functions (Your Current Setup) #

Given your existing free function signatures:

template <typename T> void Read(InputStream& s, T& val);
template <typename T> void Write(OutputStream& s, T val);

We can use SFINAE to test if these functions can be legally instantiated for a type T at compile time. Here’s how:

#include <type_traits>

// Forward declare your stream types (match your actual definitions)
class InputStream;
class OutputStream;

// Your existing Read/Write declarations
template <typename T> void Read(InputStream& s, T& val);
template <typename T> void Write(OutputStream& s, T val);

namespace detail {
    // Helper to test if Read is valid for T
    template <typename T>
    auto test_read(int) -> decltype(
        Read(std::declval<InputStream&>(), std::declval<T&>()),
        std::true_type{}
    );
    
    // Fallback if Read isn't valid
    template <typename T>
    auto test_read(...) -> std::false_type;

    // Helper to test if Write is valid for T
    template <typename T>
    auto test_write(int) -> decltype(
        Write(std::declval<OutputStream&>(), std::declval<T>()),
        std::true_type{}
    );
    
    // Fallback if Write isn't valid
    template <typename T>
    auto test_write(...) -> std::false_type;
} // namespace detail

// The final compile-time check
template <class T>
constexpr bool is_serializable() {
    // A type is serializable ONLY if both Read AND Write are valid
    return decltype(detail::test_read<T>(0))::value 
        && decltype(detail::test_write<T>(0))::value;
}

How This Works: #

• The test_read and test_write pairs use overloading: the int-parameter overload is prioritized if the Read/Write expression is valid (substitution succeeds), returning std::true_type.
• If substitution fails (e.g., no Read specialization for T), the variadic ... overload is used instead, returning std::false_type.
• is_serializable combines both checks to ensure both functions exist for the type.

Test It Out: #

// Example custom class with Read/Write specializations
class MyClass {};
template <> void Read(InputStream&, MyClass&);
template <> void Write(OutputStream&, MyClass);

// Compile-time assertions
static_assert(is_serializable<std::vector<std::string>>(), "vector<string> should be serializable");
static_assert(is_serializable<std::map<int, MyClass>>(), "map<int, MyClass> should be serializable");
static_assert(!is_serializable<std::tuple<int, float>>(), "tuple isn't serializable (add Read/Write first!)");

2. Simplified C++20 Version with requires Expressions #

If you’re using C++20 or later, you can replace the SFINAE helpers with a cleaner requires expression that directly checks the function calls:

template <class T>
constexpr bool is_serializable() {
    return requires(InputStream& s_in, OutputStream& s_out, T val, T& ref) {
        Read(s_in, ref);   // Check if Read can be called with our stream and T&
        Write(s_out, val); // Check if Write can be called with our stream and T
    };
}

This is more readable and directly mirrors the conditions you care about.

3. Alternative: Checking for a Specialized Serializer Class #

If you switch to a Serializer template class pattern (where you specialize a struct for serializable types), we can adjust the check to detect valid specializations:

// Primary template (no serialization support by default)
template <typename T>
struct Serializer;

// Example specialization for MyClass
template <>
struct Serializer<MyClass> {
    static void Read(InputStream& s, MyClass& val) { /* ... */ }
    static void Write(OutputStream& s, const MyClass& val) { /* ... */ }
};

namespace detail {
    template <typename T>
    auto test_serializer(int) -> decltype(
        Serializer<T>::Read(std::declval<InputStream&>(), std::declval<T&>()),
        Serializer<T>::Write(std::declval<OutputStream&>(), std::declval<const T&>()),
        std::true_type{}
    );
    
    template <typename T>
    auto test_serializer(...) -> std::false_type;
} // namespace detail

template <class T>
constexpr bool is_serializable() {
    return decltype(detail::test_serializer<T>(0))::value;
}

This checks if Serializer<T> has static Read and Write members with matching signatures.

Key Tips #

• Signature Matching: Make sure the checks exactly match your actual Read/Write signatures (e.g., if Write takes a const T& instead of T, update the test expressions accordingly).
• Template Types: For containers like std::vector<T>, as long as your Read/Write templates are properly specialized or overloaded to handle them, the check will automatically recognize them as serializable.
• Compile-Time Safety: The static_assert examples let you catch missing serialization support at compile time, avoiding runtime errors.

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