为什么调用重载的构造函数会导致调用默认构造函数？

Question

My C++ Programm always calls too more constructors than i intended to. It should create an edge, which then automatically creates two nodes by the string-input of the overloaded edge-constructor.

But it first calls the default-constructor of the node objects and then the overloaded self-defined constructor. The destructors do not delete the default nodes immediately. That causes an error in my program.

The problem is that the program should count the amount of objects and allocate an appropriate ID related to the amount of objects.

Compiler-Output

Default-Constructor
Default-Constructor
Overload-Constructor
ID: 1 numInstances: 2
Destructor
Overload-Constructor
ID: 2 numInstances: 1
Destructor
Edge:  -> Node_0002

Destructor
Destructor
Program ended with exit code: 0

Here is a snippet for you to see the code which most likely causes the error:

main.cpp

int main() {
    Edge e1 = Edge("1", "2");
    std::cout << "Edge: " << e1.toString() << endl;
    return 0;
}

node.hpp

double Node::numInstances = 0;
Node::Node()
{
    numInstances++;
    cout << "Default-Constructor" << endl;
    double idNumber = numInstances;
    m_id = setUpIdString(idNumber);
}

Node::Node(string id)
{
    double idNumber = getNumberFromString(id);
    cout << "Overload-Constructor" << endl;
    cout << "ID: " << idNumber << " numInstances: " << numInstances << endl;
    if (idNumber > numInstances) {
        numInstances++;
        m_id = setUpIdString(idNumber);
    }
}

Node::~Node()
{
    numInstances--;
    cout << "Destructor" << endl;
}

edge.cpp

Edge::Edge(string src, string dst)
{
    m_srcNode = Node(src);
    m_dstNode = Node(dst);
}

EDIT:

node.hpp

class Node
{
public:
    Node();
    Node(string id);
    ~Node();
    string getId();

private:
    string m_id;
    static double numInstances;
};

edge.hpp

class Edge
{
public:
    Edge(Node& rSrc, Node& rDst);
    Edge(string src, string dst);
    string toString();
    Node& getSrcNode();
    Node& getDstNode();

private:
    Node m_srcNode;
    Node m_dstNode;
};

Answer 1

A constructor is not like other functions in C++. A constructor's job is to initialize an object. In order to ensure the object gets initialized in a sensible way, all of the member objects (and base objects) need to be initialized. *This happens before the opening brace of the constructor body, so that everything is in a sensible state when you're in the constructor body.

To make sure this happens in the way you want, you can use an initializer list (note that this term also refers to something else when initializing various containers; if you've heard the term before in relation to that, it's not what I'm discussing here). After the function signature, you put a colon, followed by each member of your class (in the same order they're declared in the class) and how you want to initialize it. For example, if you have the following struct

struct A {
    int i;
    char c;
    std::string s;
    A();
};

you can declare define your constructor as

A::A() : i{17}, c{'q'}, s{"Hello, mrb! Welcome to Stack Overflow"}
{
    // Nothing to do in the body of the constructor
}

That way, an A object's members are initialized to 17 , 'q' , and a greeting before the start of the function , and are not initialized any other way.

---

Since you do not do this, the compiler instead uses the default constructor for the nodes. You then create other nodes inside the constructor body, and assign them to the nodes in your class.

Answer 2

m_srcNode = Node(src);
m_dstNode = Node(dst);

Here, the two objects are first constructed with default constructor, then the overloaded constructed is called with Node(src) and Node(dst) . After that, the implicitly defined copy assigner is called to assign the temporary objects to m_srcNode and m_dstNode . Finally the temporary objects are destroyed.

If you want to avoid extra constructor calls, you can write a member initializer list :

Edge::Edge(string src, string dst) : m_srcNode(src), m_dstNode(dst) {}