C++中使用SFINAE禁用含指针的POD结构作为网络传输模板参数

实现思路 #

你需要自定义编译期类型萃取逻辑，递归检查传入类型的所有非静态成员是否包含指针类型。标准库提供的is_trivially_copyable、is_standard_layout只能校验类型的内存布局特性，无法识别成员是否为指针，因为指针本身也属于可平凡拷贝、符合标准布局的类型。

方案1：自动编译期检查（C++17及以上） #

基于聚合类型结构化绑定和编译期成员计数实现自动检查，不需要手动标记类型，适合结构体数量不多的场景：

#include <type_traits>
#include <utility>

namespace detail {
    // 通用类型转换探针，用于探测聚合成员数量
    template <std::size_t N>
    struct any_type {
        template <typename T>
        constexpr operator T() const noexcept;
    };

    // 探测指定成员数下是否可聚合初始化
    template <typename T, std::size_t... Is>
    constexpr auto count_members(std::index_sequence<Is...>) 
        -> decltype(T{any_type<Is>{}...}, std::size_t{}) {
        return sizeof...(Is);
    }
    template <typename T>
    constexpr std::size_t count_members(...) {
        return -1;
    }

    // 递归计算聚合类型的成员数量，默认支持最多16个成员，可自行扩展上限
    template <typename T, std::size_t N = 0>
    constexpr std::size_t aggregate_member_count_v = [] {
        constexpr std::size_t cnt = count_members<T>(std::make_index_sequence<N>{});
        if constexpr (cnt == N) {
            if constexpr (count_members<T>(std::make_index_sequence<N + 1>{}) == N + 1) {
                return aggregate_member_count_v<T, N + 1>;
            } else {
                return N;
            }
        } else {
            return aggregate_member_count_v<T, N + 1>;
        }
    }();
}

// 前置声明：类型不含指针成员的校验变量
template<typename T>
constexpr bool has_no_pointer_members_v = false;

// 基础安全类型特化：算术类型、枚举、空类型
template<typename T>
requires std::is_arithmetic_v<T> || std::is_enum_v<T> || std::is_void_v<T>
constexpr bool has_no_pointer_members_v<T> = true;

// 指针类型特化：所有指针类型都判定为不安全
template<typename T> constexpr bool has_no_pointer_members_v<T*> = false;
template<typename T> constexpr bool has_no_pointer_members_v<T* const> = false;
template<typename T> constexpr bool has_no_pointer_members_v<T* volatile> = false;
template<typename T> constexpr bool has_no_pointer_members_v<T* const volatile> = false;

// 数组类型特化：检查元素类型即可
template<typename T, size_t N>
constexpr bool has_no_pointer_members_v<T[N]> = has_no_pointer_members_v<T>;
template<typename T>
constexpr bool has_no_pointer_members_v<T[]> = has_no_pointer_members_v<T>;

// 标准布局聚合类型特化：递归检查所有成员
template<typename T>
requires std::is_standard_layout_v<T> && std::is_aggregate_v<T>
constexpr bool has_no_pointer_members_v<T> = []{
    constexpr auto cnt = detail::aggregate_member_count_v<T>;
    if constexpr (cnt == 0) return true;
    else if constexpr (cnt == 1) {
        auto [m1] = std::declval<T>();
        return has_no_pointer_members_v<decltype(m1)>;
    } else if constexpr (cnt == 2) {
        auto [m1, m2] = std::declval<T>();
        return has_no_pointer_members_v<decltype(m1)> && has_no_pointer_members_v<decltype(m2)>;
    }
    // 可根据业务需求自行扩展3~16个成员的校验逻辑
    else {
        static_assert(cnt <= 2, "Too many members, extend the check list");
        return false;
    }
}();

// 改造后的网络传输模板类
template<typename POD>
class ToNetwork {
    static_assert( std::is_standard_layout< POD >::value, "Type must be standard layout" );
    static_assert( has_no_pointer_members_v<POD>, "Type can not contain pointer members for network transmission" );
    POD m_payload;
};

// 测试用例调整：将S1改为聚合类型兼容自动检查
struct S1 {
    int x = 42;
};
// bad
struct S2 {
    int *x;
};

ToNetwork< S1 > s1; // 编译通过
ToNetwork< S2 > s2; // 编译触发指针校验报错

方案2：手动标记（生产环境更推荐） #

如果是生产环境的网络传输场景，更推荐手动标记安全类型的方案，逻辑简单、兼容性强、不会出现编译器适配问题，还能避免意外修改结构体导致的风险：

#include <type_traits>

// 全局网络安全类型标记
template<typename T>
constexpr bool is_network_safe_v = false;

// 手动标记所有允许用于网络传输的类型
template<> constexpr bool is_network_safe_v<int> = true;
template<> constexpr bool is_network_safe_v<S1> = true;
// 指针类型统一标记为不安全
template<typename T> constexpr bool is_network_safe_v<T*> = false;

template<typename POD>
class ToNetwork {
    static_assert( std::is_standard_layout< POD >::value, "Type must be standard layout" );
    static_assert( is_network_safe_v<POD>, "Type is not allowed for network transmission" );
    POD m_payload;
};

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