我需要检查一个类 C有一个默认构造函数，可以是隐式的也可以是自定义的，并且可以是 public , protected或 private .

我尝试使用 std::is_default_constructible<C>::value , 如果 C 则返回真有一个 public默认构造函数(隐式或自定义)但 false如果C有一个 protected或 private默认构造函数(尽管接缝是标准行为。)

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

注意(如果这可能有帮助):检查是从 friend 函数执行的类(class) C待检查。

我需要执行此检查以默认构造对应于 nullptr 的对象m_objs 的指针元组，一个 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有一个 [private] 默认构造函数和 Foo<A,B>是 B 的 friend 。

最佳答案

我将提供一个简化的示例，使事情变得更容易。然后你可以将它适应你的 Foos 类。我的想法是如下专门化我的模板化 friend 类

#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 具有默认构造函数，无论它是私有(private)的、 protected 还是公共(public)的，候选 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;
}

关于c++ - 如何检查类是否具有默认构造函数，公共(public)的、 protected 或私有(private)的，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/37211416/