标签: default-constructor

假设我有以下代码

class C {
    int i;
    String s;

    C(){
        System.out.println("In main constructor");
        // Other processing
    }

    C(int i){
        this(i,"Blank");
        System.out.println("In parameterized constructor 1");
    }

    C(int i, String s){
        System.out.println("In parameterized constructor 2");
        this.i = i;
        this.s = s;
        // Other processing 
        // Should this be a copy-paste from the main contructor? 
        // or is there any way to call it? 
    }
    public void show(){
        System.out.println("Show Method : " + i + ", "+ s);
    }
}

我想知道，有什么方法可以从参数化构造函数（即C(int i, String …

我想在 C++ 类中进行“懒惰构造”，一个简单的方法是这样的：

#include "b.hpp" // class B

class A {

public:
  // invoke B() in b.hpp, this constructor do not actually do init      
  A(int v_in) : v(v_in) {} 

  void foo() {
    if(flag == false) {
      b = create_B_obj();
      flag = true;
    }
  }
private:
  B create_B_obj() {
    // some expensive ops
    //...
  }

private:
  bool flag = false;
  B b;
  int v;
};

但是存在的一个问题是 B 可能不包含默认构造函数 ( B())，那么在这种情况下我该如何做“懒惰构造”呢？

顺便说一句：我项目中的 B 类就像一个套接字，需要进行连接或类似绑定的调用，所以我想把这些昂贵的操作懒惰。

默认构造函数将所有实例和类成员初始化为其默认值。

上面的说法是对还是错？

无法std::optional<T>被平凡缺省构造？

似乎唯一的障碍是engaged标志的初始化，但零初始化不处理这种情况吗？

该文件说：

在 JVM 上，如果主构造函数的所有参数都有默认值，编译器将生成一个额外的无参数构造函数，它将使用默认值。这使得将 Kotlin 与通过无参数构造函数创建类实例的库（例如 Jackson 或 JPA）一起使用变得更加容易。

但情况似乎并非如此：

Welcome to Kotlin version 1.2.71 (JRE 10.0.2+13-Ubuntu-1ubuntu0.18.04.2)
Type :help for help, :quit for quit
>>> class A(val x: Int = 1, val y: Int = 2)
>>> for (c in A::class.java.constructors) println(c)
public Line_0$A(int,int,int,kotlin.jvm.internal.DefaultConstructorMarker)
public Line_0$A(int,int)
>>> 

我错过了什么？

我最近注意到我的性能受到了影响，因为我声明了一个默认构造函数，例如：

Foo() = default;

代替

Foo() {}

（仅供参考，我需要明确声明它，因为我还有一个可变参数构造函数，否则会覆盖默认构造函数）

这对我来说似乎很奇怪，因为我认为这两行代码是相同的（好吧，只要默认构造函数是可能的。如果默认构造函数不可用，第二行代码会产生错误，第一行会产生错误）隐式删除默认构造函数。'不是我的情况！）。

好的，所以我做了一个小测试器，结果根据编译器的不同而有很大差异，但是在某些设置下，我得到了一致的结果，一个比另一个更快：

#include <chrono>

template <typename T>
double TimeDefaultConstructor (int n_iterations)
{
    auto start_time = std::chrono::system_clock::now();

    for (int i = 0; i < n_iterations; ++i)
        T t;

    auto end_time = std::chrono::system_clock::now();

    std::chrono::duration<double> elapsed_seconds = end_time - start_time;

    return elapsed_seconds.count();
}

template <typename T, typename S>
double CompareDefaultConstructors (int n_comparisons, int n_iterations)
{
    int n_comparisons_with_T_faster = 0;

    for (int i = 0; i < n_comparisons; ++i)
    {
        double time_for_T = TimeDefaultConstructor<T>(n_iterations);
        double time_for_S …

我编写了一个实用程序类（我猜它充当辅助类），它只有几个要在另一个类中使用的静态成员函数。它没有任何非静态成员（变量或函数）。所以它也没有任何显式的 ctors或dtor。

问题是，我的编译器（GCC v11.2 和 -std=c++20）是否仍然为实用程序类生成隐式默认 ctor 和 dtor ？如果是这样，那么我应该如何防止它这样做？因为我没有在代码中初始化该类的任何实例。

我从cppreference发现了这个例子：

...\n\nstruct T3\n{\n    int mem1;\n    std::string mem2;\n    T3() {} // user-provided default constructor\n}\n\n...\n

此示例清楚地表明给定的构造函数是用户提供的构造函数，因为它在第一个声明中没有显式默认或删除；根据 [dcl.fct.def.default]/5：

\n

[..] 如果函数是用户声明的并且在其第一次声明时未\n显式默认或删除，则该函数是用户提供的 [..]

\n

现在，根据 [dcl.init.aggr]/1

\n

聚合是一个数组或一个类（第 11 条）

\n

\n
• (1.1) \xe2\x80\x94 没有用户声明或继承的构造函数 (11.4.5)，
\n
• (1.2) \xe2\x80\x94 没有私有或受保护的直接非静态数据成员 (11.8)，
\n
• (1.3) \xe2\x80\x94 无虚函数 (11.7.3)，以及
\n
• (1.4) \xe2\x80\x94 无虚拟、私有或受保护的基类 (11.7.2)。
\n

\n

看来我的类满足上述所有要求，成为一个聚合，包括点 (1.1)，因为给定的构造函数不是用户声明的。

那么为什么下面的代码格式错误（在带有 c++20 标志的 g++12.2 上测试）：

static_assert(std::is_aggregate<T3>::value); // fail\n

为什么静态断言失败？

我见过很多次人们在派生类构造函数初始值设定项列表中添加基类的默认构造函数，如下所示

DerivedClass::DerivedClass(int x) : BaseClass(), member_derived(x)
{
    //Do something;
}

派生类构造函数默认调用基类的默认构造函数。BaseClass()上面的初始化列表中的是多余的吗？

#include <iostream>
#include <memory>

using namespace std;

class Init {
private:
    int x;
public:
    Init(int y) {
        x = y;
        cout << "default constructor called" << endl;
        
    }
    
    Init(std::shared_ptr<Init> z) {
        this->x = z->x;
        cout << "copy constructor called" << endl;
    }
};

int main()
{
    int k = 5;
    std::shared_ptr<Init> a = std::make_shared<Init>(k);
    std::shared_ptr<Init> b(a);

    return 0;
}

我的期望是同时调用默认构造函数和复制构造函数，但只调用默认构造函数。可能是什么问题？

输出是： 默认构造函数称为