何时在运算符重载示例C ++中调用构造函数和析构函数

Question

I am trying to figure out exactly when Constructors and Destructors get called. Sample code:

 #include <iostream>
 using namespace std;

 class A{
 public:
     A();
     A(int);
     A operator+(const A& rhs) const;
     ~A();
 public:
     int x;
 };

 A A::operator+(const A& rhs) const
 {
     A r(x + rhs.x);
     cout<<"end A operator"<<endl;
     return r;
 }

 A::A(int y): x(y)
 {
     cout<<"Constructor A called"<<endl;
 }

 A::~A()
 {
     cout<<"Destructor A called"<<endl;

 }

 //////////

 class B{
 public:
     B();
     B(int);
     B operator+(B rhs) const;
     ~B();
 public:
     int x;
 };

 B B::operator+(B rhs) const
 {
     cout<<"beginning B operator"<<endl;
     return B(x + rhs.x);
 }

 B::B(int y): x(y)
 {
     cout<<"Constructor B called"<<endl;
 }

 B::~B()
 {
     cout<<"Destructor B called"<<endl;
 }

 int main()
 {
     cout<<"line 1 main()"<<endl;
     A a(1);
     cout<<"line 2 main()"<<endl;
     B b(2);

     cout<<"\nline 3 main()"<<endl;
     a = a + a;

     cout<<"\nline 4 main()"<<endl;
     b = b + b;

     cout<<"\nend of main"<<endl;
 }

so when I call this, I get the output:

 line 1 main()
 Constructor A called
 line 2 main()
 Constructor B called

 line 3 main()
 Constructor A called
 end A operator
 Destructor A called

 line 4 main()
 beginning B operator
 Constructor B called
 Destructor B called
 Destructor B called

 end of main
 Destructor B called
 Destructor A called

so i of course understand the first block of the output. I explicitly call the two constructors. The second block of code, there is the A constructor that gets called when you create the object r

 A r(x + rhs.x);

1. Now when the A destructor gets called here is it because r goes out of scope? Which means that the destructor is called from within the A operator overload+

Then the 3rd block of output code. The constructor B gets called on this line of code.

 return B(x + rhs.x);

1. Now my biggest question is why does the B destructor get called twice here? Where does it get called from- main() or the B operator overload+ ?

Answer 1

In the second block of code, the destructor for A is invoked when the variable r falls out of scope.

In the third block of code, you're really constructing two B object. The first is being constructed because you're passing B in by value, which invokes the copy constructor. The default copy constructor created by the compiler doesn't include code to print out "Constructor B called", so you're not seeing that the constructor is called in your output. The second constructor is invoked, as you said, on the return line, after which point both the return value and the rhs variable fall out of scope, and the destructors are called for both objects.