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

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 ()在类型上，因为它是私有(private)方法。这也没有告诉我是否 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

您需要将 foo() 的调用作为 Fooer 构造函数声明的一部分，并使构造函数 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);