如何检查一个类是否具有默认构造函数，无论是公共的、受保护的还是私有的

Question

我需要检查一个类 C 是否具有默认构造函数，无论是隐式的还是自定义的，以及 public、protected 或 private。

我尝试使用std::is_default_constructible<C>::value，如果C 具有public 默认构造函数（隐式或自定义）则返回true，但false 如果C 具有protected 或private 默认构造函数（不过，接缝似乎是标准行为。）

有什么方法可以检查一个类是否有protected 或private 默认构造函数？

注意（如果这可能有帮助）：检查是从要检查的 C 类的 friend 函数执行的。

---

我需要执行此检查，以便默认构造与 m_objs 元组的 nullptr 指针相对应的对象，Foo 对象的成员（下面的部分 Foo 定义）：

template<class... Objects>
class Foo
{
public:
    Foo(Objects*... objects)
    : m_objs(objects...)
    {
        // User construct a Foo objects passing a pack of pointers
        // some of them are nullptr, some are not.
        // The following call should default-construct objects corresponding
        // to the null pointers of m_objs member tuple:
        objs_ctor<Objects...>();
    }
private:
    template<class Obj, class O1, class ...On>
    void objs_ctor()
    {
        objs_ctor<Obj>(); objs_ctor<O1, On...>();
    }
    template<class Obj>
    typename std::enable_if<std::is_default_constructible<Obj>::value, void>::type
    objs_ctor()
    {
        Obj*& obj = std::get<Obj*>(m_objs);
        if (obj == nullptr)
            obj = new Obj;    // default-construct Obj
    }
    template<class Obj>
    typename std::enable_if<!std::is_default_constructible<Obj>::value, void>::type
    objs_ctor()
    {
        Obj*& obj = std::get<Obj*>(m_objs);
        assert(obj != nullptr);   // terminate if not pre-constructed
    }

private:
    std::tuple<Objects*...>     m_objs;
};

打算用作：

struct A { };
class B {
    B() = default;

    template <class... Ts>
    friend class Foo;
};

int main() {
    // currently asserts, even though Foo<A,B> is a friend of B
    // and B is default-constructible to its friends
    Foo<A, B> foo(nullptr, nullptr);
}

上面的示例断言因为std::is_default_constructible<B>::value 为假，即使B 有一个[私人] 默认 ctor 并且Foo<A,B> 是 B 的朋友。

Answer 1

我将提供一个简化的示例以使事情变得更容易。然后你可以将它调整到你的 Foos 类。这个想法是专门化我的模板化朋友类如下

#include <iostream>    

// forward declaration
template <class... T>
struct Friend;

struct testing_tag;

// specialisation simply to check if default constructible
template <class T>
struct Friend<T, testing_tag> {

  // sfinae trick has to be nested in the Friend class
  // this candidate will be ignored if X does not have a default constructor
  template <class X, class = decltype(X())>
  static std::true_type test(X*);

  template <class X>
  static std::false_type test(...);

  static constexpr bool value = decltype(test<T>(0))::value;
};

请注意，只要 X 具有默认构造函数，无论它是私有的、受保护的还是公有的，std::true_type 候选者都将始终有效。现在测试一下

class default_public {

  template <class... T>
  friend struct Friend;

};

class default_protected {

  template <class... T>
  friend struct Friend;

protected:
  default_protected() {}
};

class default_private {

  template <class... T>
  friend struct Friend;

private:
  default_private() {}

};

class no_default {

public:
  no_default(int x){}
};

// a convenient name to test with
template <class T>
using has_any_default_constructor = Friend<T, testing_tag>;

int main() {
  std::cout << has_any_default_constructor<default_public>::value << std::endl;
  std::cout << has_any_default_constructor<default_protected>::value << std::endl;
  std::cout << has_any_default_constructor<default_private>::value << std::endl;
  std::cout << has_any_default_constructor<no_default>::value << std::endl;
}

Answer 2

问题在于，如果一个类既没有公共的、保护的也没有私有的默认构造函数，实例的简单默认定义会给出编译错误，而不是运行时异常。所以测试很简单：如果友元函数C c;中的这个表达式编译，则该类有一个默认的ctor，可以是public、protected或private。

只看示例代码：

#include <iostream>
#include <string>

class Cwith {
private:
    std::string name;
    Cwith(): name("default ctor") {}
    friend void build();
};

class Cwithout {
private:
    std::string name;
    Cwithout(const std::string& name): name(name) {};
    friend void build();
};

void build() {
    Cwith cw;
    std::cout << cw.name << std::endl;
    Cwithout cwo;   // error : class Cwithout has no defaut constructor
    std::cout << cwo.name << std::endl;
}

int main() {
    build();
    return 0;
}

但我无法想象运行时测试...

Answer 3

我的理解是你想检查你的friend 是否可以默认构造一个类。诀窍是您必须将 SFINAE 置于 friend 函数的范围内。为此，您需要模板。要拥有本地模板，您需要通用 lambda。

我们从一个可以传递多个 lambda 表达式的重载器开始。可能有更好的写法：

template <class... Fs>
struct overload {
    void operator()();
};

template <class F, class... Fs>
struct overload<F, Fs...> : F, overload<Fs...> {

    overload(F&& f, Fs&&... fs)
    : F(std::forward<F>(f))
    , overload<Fs...>(std::forward<Fs>(fs)...)
    { }

    using F::operator();
    using overload<Fs...>::operator();
};

template <class... Fs>
overload<std::decay_t<Fs>...> make_overload(Fs&&... fs) {
    return {std::forward<Fs>(fs)...};
}

然后传入重载、通用、SFINAE-d lambdas（需要 C++14）。假设我们有：

struct Q {
    friend void foo();
};

template <class T>
struct tag_t { using type = T; };

template <class T>
constexpr tag_t<T> tag{};

那么我们可以这样写：

void foo() {
    auto f = make_overload(
        [](auto x) -> decltype( typename decltype(x)::type(), void() ) { 
            Q q;
            std::cout << "I can do it.\n";
        },
        [](...) {
            std::cout << "What do you want here?\n";
        });

    f(tag<Q>, 0); 
}

如果works 是朋友，那么第一个重载是可行的并且是首选的——所以你明白了，它构造了一个Q，因为它可以。如果works 不是朋友，则第一个重载不可行，因此您将获得第二个重载。

关键是我们在works() 中测试Q（typename decltype(x)::type() 部分）的构造——所以它要么被友谊覆盖。

---

所以对于你的具体用法，那就是：

template <class Obj>
objs_ctor() {
    Obj*& obj = std::get<Obj*>(m_objs);

    auto ctor = make_overload(
        [&](auto x) -> decltype( typename decltype(x)::type(), void() ) { 
            if (!obj) {
                obj = new Obj;
            }
        },
        [=](...) {
            assert(obj);
        });

    ctor(tag<Obj>);
}