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不会检查构造函数 definition 是否格式正确，只有表达式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);

Answer 2

这里的问题是Fooer的构造函数不是“对SFINAE友好的”。它要求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

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

3 个答案: