有一个非模板化的类，它有一个模板化的构造函数。是否可以在此类构造函数中初始化成员变量之前检查静态断言？​​

例如，下面的代码在检查 T 是否有这样的方法之前执行 T::value()。

class MyClass
{
public:
    template<typename T>
    MyClass(const T &t)
        : m_value(t.value())
    {
        static_assert(HasValueMethod<T>::value, "T must have a value() method");
    }

private:
    int m_value;
};

将 static_assert 放在构造函数的主体中工作正常，除了它在最后打印“T must have a value() method”，在来自成员初始化列表的所有错误消息之后，例如:

prog.cpp: In instantiation of ‘MyClass::MyClass(const T&) [with T = int]’:
prog.cpp:24:16:   required from here
prog.cpp:12:21: error: request for member ‘value’ in ‘t’, which is of non-class type ‘const int’
         : m_value(t.value())
                   ~~^~~~~
prog.cpp:14:9: error: static assertion failed: T must have a value() method
         static_assert(HasValueMethod<T>::value, "T must have a value() method");
         ^~~~~~~~~~~~~

我觉得这有点令人困惑，想知道是否可以在尝试初始化成员变量之前打印“T 必须有一个 value() 方法”。

我知道我可以使用 enable_if 和 SFINAE 为不合适的 T 禁用此构造函数，但我想告诉用户一些比“方法不”更有意义的事情找到了”。

最佳答案

您可以使用 std::enable_if SFINAE 出执行 static_assert 的构造函数基于是否T具有函数成员 value() , 将真正的实现分开。

如果 T，则选择第一个构造函数有 value()方法，并正常实现(除了需要 std::enable_if 才能被选中):

template <typename T, typename = std::enable_if_t<HasValueMethod<T>::value>>
MyClass(const T &t) : m_value(t.value())
{}

因此我们需要将第二个构造函数从函数重载中 SFINAEd，因为第一个构造函数已经知道 T::value存在:

template <typename T, typename = std::enable_if_t<!HasValueMethod<T>::value>>
MyClass(const T &, ...)
{
  static_assert(HasValueMethod<T>::value, "T must have a value() method");
}

注意可变参数 ... :需要它来区分构造函数的原型(prototype)，因此它不会与第一个冲突(它们需要不同，否则模棱两可的原型(prototype)会导致编译错误)。你不会向它传递任何东西，它只是为了让它成为一个不同的原型(prototype)。

还要注意 std::enable_if 的谓词相同但被否定。当HasValueMethod<T>::value为 false，第一个构造函数是 SFINAEd 函数重载，但不是第二个构造函数，后者将触发静态断言。

您仍然需要使用 HasValueMethod<T>::value在静态断言的参数中，所以它取决于 T被执行。否则，只放 false无论是否被选中，它都会始终触发。

这是 GCC 在 T 时打印的内容没有.value() :

main.cpp: In instantiation of 'MyClass::MyClass(const T&, ...) [with T = A; <template-parameter-1-2> = void]':
main.cpp:35:18:   required from here
main.cpp:21:9: error: static assertion failed: T must have a value() method
         static_assert(HasValueMethod<T>::value, "T must have a value() method");

         ^~~~~~~~~~~~~

这是 Clang 的:

main.cpp:21:9: error: static_assert failed "T must have a value() method"
        static_assert(HasValueMethod<T>::value, "T must have a value() method");
        ^    

总而言之，这种方法存在一个问题(正如@T.C. 在评论中指出的那样):MyClass从未评估的上下文的角度来看，现在可以从任何东西转换。也就是说，

static_assert(std::is_convertible_v</*anything*/, MyClass>); // Always true.

在 C++20 中，当有希望的概念出现时，这很容易用 requires 解决。子句:

template <typename T>
  requires HasValueMethod<T>::value
MyClass(const T &t) : m_value(t.value())
{}

你可以直接表达HasValueMethod<T>在requires子句也一样:

template <typename T>
  requires requires (T a) { { a.value() } -> int; }
MyClass(const T &t) : m_value(t.value())
{}

或转换HasValueMethod<T>变成一个真实的概念:

template <typename T>
concept HasValueMethod = requires (T a) {
    { a.value() } -> int;
};

// Inside `class MyClass`.
template <typename T>
  requires HasValueMethod<T>
MyClass(const T &t) : m_value(t.value())
{}

这样的解决方案使std::is_convertible_v<T, MyClass>也按预期工作。

关于c++ - 构造函数的初始化列表之前的 static_assert，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/47496515/