如何编写可访问类型成员变量且跳过不存在成员的C++模板？

你遇到的编译错误本质是：模板函数实例化时，编译器会检查所有代码的有效性，但test1没有b成员、test2没有a成员，导致实例化对应类型时触发错误。下面是几种实用的解决方法：

方法一：C++17+ 用if constexpr实现条件编译（最简洁） #

利用C17的if constexpr（编译期条件判断），配合成员检测模板，让编译器只对当前类型存在的成员编译对应代码。C20及以上可以直接用requires简化检测，C++17则用void_t做兼容。

C++20版本代码 #

#include <iostream>
#include <type_traits>

struct test1 {
    int a;
};

struct test2 {
    int b;
};

// 编译期检测类型是否有a成员
template<typename T>
constexpr bool has_a = requires(T t) { t.a; };

// 编译期检测类型是否有b成员
template<typename T>
constexpr bool has_b = requires(T t) { t.b; };

template <class T>
void func(T& test) {
    // 仅当T有a成员时，才编译这段代码
    if constexpr (has_a<T>) {
        test.a = 1;
    }
    // 仅当T有b成员时，才编译这段代码
    if constexpr (has_b<T>) {
        test.b = 2;
    }
}

int main()
{
    std::cout<<"Hello World\n";
    test1 t1;
    test2 t2;
    func(t1); // 仅执行test.a = 1
    func(t2); // 仅执行test.b = 2
    std::cout << t1.a << "\n" << t2.b << "\n";
    return 0;
}

C++17兼容版本代码 #

如果编译器不支持C++20的requires，用void_t实现成员检测：

#include <iostream>
#include <type_traits>

struct test1 {
    int a;
};

struct test2 {
    int b;
};

// 编译期检测类型是否有a成员（C++17兼容）
template<typename T, typename = void>
struct has_a : std::false_type {};

template<typename T>
struct has_a<T, std::void_t<decltype(std::declval<T>().a)>> : std::true_type {};

template<typename T>
constexpr bool has_a_v = has_a<T>::value;

// 编译期检测类型是否有b成员（C++17兼容）
template<typename T, typename = void>
struct has_b : std::false_type {};

template<typename T>
struct has_b<T, std::void_t<decltype(std::declval<T>().b)>> : std::true_type {};

template<typename T>
constexpr bool has_b_v = has_b<T>::value;

template <class T>
void func(T& test) {
    if constexpr (has_a_v<T>) {
        test.a = 1;
    }
    if constexpr (has_b_v<T>) {
        test.b = 2;
    }
}

int main()
{
    std::cout<<"Hello World\n";
    test1 t1;
    test2 t2;
    func(t1);
    func(t2);
    std::cout << t1.a << "\n" << t2.b << "\n";
    return 0;
}

方法二：用SFINAE拆分重载函数 #

通过std::enable_if结合成员检测，给不同特性的类型提供对应的函数重载，编译器会自动匹配符合条件的版本。

#include <iostream>
#include <type_traits>

struct test1 {
    int a;
};

struct test2 {
    int b;
};

// 成员检测模板（同C++17版本）
template<typename T, typename = void>
struct has_a : std::false_type {};

template<typename T>
struct has_a<T, std::void_t<decltype(std::declval<T>().a)>> : std::true_type {};

template<typename T>
constexpr bool has_a_v = has_a<T>::value;

template<typename T, typename = void>
struct has_b : std::false_type {};

template<typename T>
struct has_b<T, std::void_t<decltype(std::declval<T>().b)>> : std::true_type {};

template<typename T>
constexpr bool has_b_v = has_b<T>::value;

// 仅处理有a但无b的类型
template <class T, std::enable_if_t<has_a_v<T> && !has_b_v<T>, int> = 0>
void func(T& test) {
    test.a = 1;
}

// 仅处理有b但无a的类型
template <class T, std::enable_if_t<has_b_v<T> && !has_a_v<T>, int> = 0>
void func(T& test) {
    test.b = 2;
}

// 可选：处理同时有a和b的类型
template <class T, std::enable_if_t<has_a_v<T> && has_b_v<T>, int> = 0>
void func(T& test) {
    test.a = 1;
    test.b = 2;
}

int main()
{
    std::cout<<"Hello World\n";
    test1 t1;
    test2 t2;
    func(t1);
    func(t2);
    std::cout << t1.a << "\n" << t2.b << "\n";
    return 0;
}

方法三：标签分发（传统模板技巧） #

通过自定义标签类区分类型特性，再用重载的实现函数处理不同标签，避免编译期错误。

#include <iostream>
#include <type_traits>

struct test1 {
    int a;
};

struct test2 {
    int b;
};

// 定义标签类，标记不同的成员特性
struct has_a_tag {};
struct has_b_tag {};

// 编译期推导当前类型对应的标签
template<typename T>
constexpr auto get_type_tag() {
    if constexpr (requires(T t) { t.a; }) {
        return has_a_tag{};
    } else if constexpr (requires(T t) { t.b; }) {
        return has_b_tag{};
    }
}

// 针对不同标签的实现函数
void func_impl(test1& test, has_a_tag) {
    test.a = 1;
}

void func_impl(test2& test, has_b_tag) {
    test.b = 2;
}

// 对外统一接口
template <class T>
void func(T& test) {
    func_impl(test, get_type_tag<T>());
}

int main()
{
    std::cout<<"Hello World\n";
    test1 t1;
    test2 t2;
    func(t1);
    func(t2);
    std::cout << t1.a << "\n" << t2.b << "\n";
    return 0;
}

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