如何构造一个类型特征来判断一种类型的私有方法是否可以在另一种类型的构造函数中调用？

Question

我正在使用 C++17。我有如下代码：

#include <type_traits>

template <typename T>
struct Fooer
{
    Fooer (T & fooable)
    {
        fooable . foo ();
    }
};

template <typename T>
Fooer (T & fooable) -> Fooer <T>;

struct Fooable
{
private:

    void
    foo ();

    friend struct Fooer <Fooable>;
};

struct NotFooable
{
};

我想实现一个类型特征，它可以判断一个类型是否是“Fooable”。

我无法检查类型上是否有方法foo ()，因为它是私有方法。这也没有告诉我Fooer的构造函数是否可以调用该方法。

// Checking for the foo method doesn't work.

template <typename T, typename = void>
struct HasFoo;

template <typename T, typename>
struct HasFoo : std::false_type
{
};

template <typename T>
struct HasFoo
<
    T,
    std::enable_if_t
    <
        std::is_convertible_v <decltype (std::declval <T> () . foo ()), void>
    >
>
:   std::true_type
{
};

// Both of these assertions fail.
static_assert (HasFoo <Fooable>::value);
static_assert (HasFoo <NotFooable>::value);

我也无法检查Fooer <T> 是否可以通过std::is_constructible 构造，因为std::is_constructible 不会检查构造函数定义 是否格式正确，只有表达式Fooer <T> fooer (std::declval <T> ())。

// Checking constructibility doesn't work either.

template <typename T, typename = void>
struct CanMakeFooer;

template <typename T, typename>
struct CanMakeFooer : std::false_type
{
};

template <typename T>
struct CanMakeFooer
<
    T,
    std::enable_if_t <std::is_constructible_v <Fooer <T>, T &>>
>
:   std::true_type
{
};

// Neither of these assertions fail.
static_assert (CanMakeFooer <Fooable>::value);
static_assert (CanMakeFooer <NotFooable>::value);

如果我真的尝试调用构造函数，我会得到预期的错误，尽管它并没有让我更接近实现类型特征。

void
createFooer ()
{
    Fooable fooable;
    NotFooable not_fooable;

    // This works fine.
    { Fooer fooer (fooable); }

    // This correctly generates the compiler error: no member named 'foo' in
    // 'NotFooable'
    { Fooer fooer (not_fooable); } 
}

我想避免将类型特征声明为 Fooable 类型的朋友，并且我想避免公开 'foo'。

如果我能以某种方式使类型特征检查函数或构造函数的 定义 是否格式正确，我可以很容易地实现这种类型特征，但我不知道该怎么做，而且我在互联网上找不到任何这样的例子。

有可能做我想做的事吗？我该怎么做？

Answer 1

您需要在Fooer 构造函数的声明中调用foo()，并使构造函数对SFINAE 友好。您可以使用构造函数模板和要求的默认模板参数来执行此操作。这意味着HasFoo 只需要检查Fooer 是否可以用T 构造，而不必担心foo() 函数。

template <typename T>
struct Fooer {
  template <typename U, typename = std::void_t<
    decltype(std::declval<U &>().foo()),
    std::enable_if_t<std::is_same_v<T, U>>
  >>
  explicit Fooer(U &fooable) {
    fooable.foo();
  }
};

template <typename U>
Fooer(U &) -> Fooer<U>;

template <typename T>
struct HasFoo : std::bool_constant<
  std::is_constructible_v<Fooer<T>, T &>
> {};

struct Fooable {
private:
  void foo() {}

  friend struct Fooer<Fooable>;
};

struct NotFooable {};

static_assert(HasFoo<Fooable>::value);
static_assert(!HasFoo<NotFooable>::value);

Answer 2

这里的问题是Fooer 的构造函数不是“SFINAE-friendly”的。它要求Fooer 可以调用fooable.foo()，但就C++ 而言，声明Fooer(T &); 没有任何此类约束。

我们可以将构造函数声明改为构造函数模板，这样当类模板的模板参数不是“fooable”时，模板参数推导失败：

#include <utility>

template <typename T>
struct Fooer
{
    template <typename U = T, typename Enable =
                std::void_t<decltype(std::declval<U&>().foo())>>
    Fooer (T & fooable)
    {
        fooable . foo ();
    }
};

[使用 C++20 约束，这将变得更容易、更清晰：

// C++20 code
template <typename T>
struct Fooer
{
     Fooer (T & fooable) requires requires { fooable.foo(); }
     {
         fooable . foo ();
     }
};

]

有了这个改变，你的CanMakeFooer 应该可以工作了。虽然它可以更简单地定义为只使用主模板而没有专门化：

template <typename T>
struct CanMakeFooer :
    public std::bool_constant<std::is_constructible_v<Fooer<T>, T&>>
{};

Demo on coliru.

Answer 3

我对您的 HasFoo 使用了类似的方法，但使用函数而不是结构，它按预期工作。

Fooer (T& fooable)
{
    if constexpr (has_foo<T>(0)) {
        cout << "Yes foo" << endl;
        fooable.foo();
    }
    else {
        cout << "No foo" << endl;
    }
}

template<class Y>
static constexpr auto has_foo(Y*) -> decltype(std::declval<Y>().foo(), bool()) {
    return true;
}

template<class Y>
static constexpr bool has_foo(...) {
    return false;
}

https://wandbox.org/permlink/5GGY89YVLsfqeZ2A