如何仅在提供模板参数时启用类模板成员函数？

成员函数 API 的约束

您可以利用约束和概念，尤其是 std：：same_as 概念：

#include <concepts>

template <typename T = void>
struct A final {
    // This method is defined only when T is non-void.
    void f() requires (!std::same_as<T, void>) {} 

    // This method is defined only when T is void.
    void g() requires std::same_as<T, void> {} 
};

int main() {
    A<int> a1;
    A a2;
    a1.f(); // OK
    // a1.g(); // error
    // a2.f(); // error
    a2.g(); // OK
}

会员呢？

如果您只希望该成员存在于某些专业化中，则可以将其包装在相应地专门化的类模板中。例如：

template<typename T>
struct Value {
    T value;
};

template<>
struct Value<void> {};

另一种方法是使用帮助程序基类来继承成员，这在 A 的构造函数依赖于类型本身的特征时尤其有用。F.D.（英语：F.D.） 通常使用各种基类的 mixin 实现。std::optional

您可能还希望对类的模板参数本身进行限制，例如在类中包装哪种类型是有意义的。A

使用最小方法：

#include <concepts>

template<typename T>
struct Value {
    T value;
};

template<>
struct Value<void> {};

template <typename T = void>
struct A final {
    // This methods can be called only when T is non-void.
    T f() requires (!std::same_as<T, void>) {
        return member.value;
    } 

    // This method can be called only when T is void.
    void g() requires std::same_as<T, void> {}
private:
    Value<T> member;
};

int main() {
    A<int> a1;
    A a2;
    auto value = a1.f(); // OK
    // a1.g(); // error
    // a2.f(); // error
    a2.g(); // OK
}

您可以将“旧”方式用于专业化：

template <typename T = void>
class A final // generic case, T != void
{
public:
    void f() { std::cout << member << std::endl; }

public:
    T member;
};

template <>
class A<void> final
{
public:
    void g() { printf("No template parameter\n"); } // actually `void` and not "No".
};

通过将类转换为可变参数，将 absent 参数作为空包而不是 void 进行处理，您可以执行以下操作：

template <typename... Ts>
class A final
{
static_assert(sizeof...(Ts) < 2);
public:
    void f() requires (sizeof...(Ts) == 1) { std::cout << std::get<0>(member) << std::endl; }
    void g() requires (sizeof...(Ts) == 0) { printf("No template parameter\n"); }

public:
    std::tuple<Ts...> member;
};