标签: default-constructor

如果我们说那default constructor是没有参数的构造函数,我们还可以说编译器创建的构造函数也是一个default constructor吗？

谢谢.

我有一个简单的问题:

class my
{
};
my ob;

编译器允许我创建一个有意义的对象.而且,我知道你不能创建构造函数是私有的对象.

对我来说,它看起来,类中的所有内容private显然不是默认构造函数(因为它允许我创建对象作为默认构造函数应该是public).但令我困惑的是,public课堂上没有任何部分.

那么,public在这种情况下,它是否只创建一个部分,只在其下面放置一个默认构造函数？

或者还有其他事情发生,我的理由是不正确的？

此外,在创建/访问对象时,如何访问公共,私有和受保护的内部组织/跟踪？

我得到了这个问题,因为我从来没有创建过空类的对象.

如果我有一个值类型的泛型类型参数,我想知道一个值是否等于默认值我测试它像这样:

static bool IsDefault<T>(T value){
    where T: struct
    return value.Equals(default(T));
}

如果我没有泛型类型参数,那么我似乎必须使用反射.如果该方法必须适用于所有值类型,那么执行此测试的方法是否比我在此处所做的更好？:

static bool IsDefault(object value){
   if(!(value is ValueType)){
      throw new ArgumentException("Precondition failed: Must be a ValueType", "value");
   }
   var @default = Activator.CreateInstance(value.GetType());
   return value.Equals(@default);  
}

另外,在评估Nullable结构方面,我有什么不考虑的吗？

我创建了2个简单的类.一个类的构造函数注释为@Autowired.它接受另一个类的对象.但是这段代码失败了.

类: - 1)SimpleBean.java

@Configuration
public class SimpleBean {
  InnerBean prop1;

  public InnerBean getProp1() {
    return prop1;
  }

  public void setProp1( InnerBean prop1) {
    System.out.println("inside setProp1 input inner's property is "
        + prop1.getSimpleProp1());
    this.prop1 = prop1;
  }

  @Autowired(required=true)
  public SimpleBean(InnerBean prop1) {
    super();
    System.out.println("inside SimpleBean constructor inner's property is "
        + prop1.getSimpleProp1());
    this.prop1 = prop1;
  }
}

2)Inner.java

@Configuration
public class InnerBean {
  String simpleProp1;

  public String getSimpleProp1() {
    return simpleProp1;
  }

  public void setSimpleProp1(String simpleProp1) {
    this.simpleProp1 = simpleProp1; …

编写代码就像

struct S
{
    this() // compile-time error
    {
    }
}

给我一个错误信息说

default constructor for structs only allowed with @disable and no body.

为什么？？

有人可以指出标准中的哪个子句支持在Coliru中获得的以下行为,对于该片段:

#include <iostream>

class A
{
    int i;
    float x;

    public:
    A() : i(10) {}
    A(int i) : i(i) {}
    int GetI() { return i; }
    float GetF() { return x; }
};


int main()
{
    A a;
    A b(1);
    A x{};
    A y{1};
    std::cout << a.GetI() << '\n';
    std::cout << a.GetF() << '\n';
    std::cout << b.GetI() << '\n';
    std::cout << b.GetF() << '\n';
    std::cout << x.GetI() << '\n';
    std::cout << x.GetF() << '\n';
    std::cout << y.GetI() << '\n';
    std::cout …

从C++ 11标准§8.5p6我们得到:

如果程序要求对const限定类型T的对象进行默认初始化,则T应为具有用户提供的默认构造函数的类类型.

下面的代码应该不会编译.但它确实在Coliru和Ideone都有.

class A{};

int main() {
    const A a;
}

编辑:

在尝试理解这里发生了什么时,我最终得到了以下代码,它编译(至少它符合标准,与A用户提供的构造函数一样).但后来出现了以下问题:哪个标准子句确保a.b.j用0初始化(参见Ideone中的代码),下面是什么？

#include <iostream>
struct B { int j; B(){ std::cout << "B()" << '\n'; } };
struct A
{
    struct B b;
    int i;

    public:
    A(): i(1) { std::cout << "A()" << '\n'; }

};  

int main() {
    const A a;
    std::cout << a.b.j << '\n';
    std::cout << a.i << '\n';
}

EDIT1:

很抱歉上面的编辑,但我还没有使用Unix.上周, …

我和我的一位同事讨论过关于他人的问题

Pt pt;

和

Pt pt = Pt(); 

是等价的.我怀疑在第二种情况下可以调用复制分配,但事实证明并非如此.

当我们进行我们的小实验时,我决定测试一个奇怪的位,我的同事认为甚至不会编译:

//here the compiler calls a copy constructor and doesn't call the default constructor prior to that
// O_o
Pt pt = pt;

以下是一个工作示例:http://ideone.com/XmJSz7

所以,问题是 - 发生了什么:

Pt pt = pt;

假设foo_t具有命名构造函数的类型,make_foo().现在,我想要真正拥有123个foo - 不多也不少.所以,我在考虑一个std::array<foo_t, 123>.现在,如果foo_t是默认构造的,我会写:

std::array<foo_t, 123> pity_the_foos;
std::generate(
    std::begin(pity_the_foos), std::end(pity_the_foos),
    []() { return make_foo(); }
);

而鲍勃是我的叔叔,对吗？不幸的是...... foo_t没有默认的ctor.

那么我应该如何初始化我的数组呢？我是否需要使用一些可变模板扩展伏都教？

注意:如果有帮助,答案可能会使用C++ 11,C++ 14或C++ 17中的任何内容.

假设以下 c++17 代码：

#include <type_traits>
namespace dtl
{
   struct One
   {
      explicit One(int);
      ~One() = default;
      One(const One &) = delete;
      auto operator=(const One &) -> One & = delete;
      auto operator=(One &&) -> One & = delete;
      One(One &&); // Throwable, not default;
      int m_int;
   };
   struct Two 
   {
      explicit Two(int);
      ~Two() = default;
      Two(const Two &) = delete;
      auto operator=(const Two &) -> Two & = delete;
      auto operator=(Two &&) noexcept -> Two & = delete;
      Two(Two &&) …