By using this site, you agree to our updated Privacy Policy and our Terms of Use. Manage your Cookies Settings.
432,245 Members | 884 Online
Bytes IT Community
+ Ask a Question
Need help? Post your question and get tips & solutions from a community of 432,245 IT Pros & Developers. It's quick & easy.

CPP Output Question - related to copy-constructor and return by value

P: n/a
Hi All,

I have a doubt in understanding the output of the following program
that i executed on my system. I was using DevC++ IDE which uses minGW
based compiler.

----------------------------------------------
#include <iostream>
using namespace std;

class Integer //: public DataType
{
private:
int x;
public:
Integer(int xx = 0);
Integer(const Integer&);
~Integer();
Integer operator+(const int i);
void operator=(const Integer& i);
};

Integer::Integer(int xx) : x(xx)
{
cout<<"Integer(int) x is "<<x<<endl;
}
Integer::Integer(const Integer& i) : x(i.x)
{
cout<<"Integer(Integer&)"<<endl;
}
Integer::~Integer()
{
cout<<"~Integer()"<<endl;
}
Integer Integer::operator+(const int i)
{
cout<<"operator+ called i is "<<i<<endl;
Integer xx(x+i);
return xx;
}
void Integer::operator=(const Integer& i)
{
cout<<"operator= called i.x is "<<i.x<<endl;
x = i.x;
}

int main()
{
Integer i1(40);
Integer i3=i1+10; //Doubt understanding this
return 0;
}
-----------------------------------
Output:

Integer(int) x is 40
operator+ called i is 10
Integer(int) x is 50
~Integer()
~Integer()
-------------------------------------
I have a doubt in understanding the execution of operator+.

Inside operator+, xx is created and is returned by value. While
returning the copy-constructor of Integer should get invoked because
the output of operator+ is being assigned to i3 which is not yet
constructed, but the actual output observed is different.

Is this any kind of optimization being performed by the compiler. Is
there anything that i am missing.

I would appreciate if someone can explain this.

Regards
Sanjay Raghani
Oct 9 '08 #1
Share this Question
Share on Google+
2 Replies


P: n/a
sanjay wrote:
I have a doubt in understanding the output of the following program
that i executed on my system. I was using DevC++ IDE which uses minGW
based compiler.

----------------------------------------------
#include <iostream>
using namespace std;

class Integer //: public DataType
{
private:
int x;
public:
Integer(int xx = 0);
Integer(const Integer&);
~Integer();
Integer operator+(const int i);
void operator=(const Integer& i);
As a side note, operator= *usually* returns a reference to the same
object. It's not required, of course.
};

Integer::Integer(int xx) : x(xx)
{
cout<<"Integer(int) x is "<<x<<endl;
}
Integer::Integer(const Integer& i) : x(i.x)
{
cout<<"Integer(Integer&)"<<endl;
You misrepresent the signature of your copy c-tor. The argument is a
reference to a const integer, so I'd expect the output statement to be

cout << "Integer(Integer const&)" << endl;

<g>
}
Integer::~Integer()
{
cout<<"~Integer()"<<endl;
}
Integer Integer::operator+(const int i)
{
cout<<"operator+ called i is "<<i<<endl;
Integer xx(x+i);
return xx;
}
void Integer::operator=(const Integer& i)
{
cout<<"operator= called i.x is "<<i.x<<endl;
x = i.x;
}

int main()
{
Integer i1(40);
Integer i3=i1+10; //Doubt understanding this
return 0;
}
-----------------------------------
Output:

Integer(int) x is 40
operator+ called i is 10
Integer(int) x is 50
~Integer()
~Integer()
-------------------------------------
I have a doubt in understanding the execution of operator+.

Inside operator+, xx is created and is returned by value. While
returning the copy-constructor of Integer should get invoked because
the output of operator+ is being assigned to i3 which is not yet
constructed, but the actual output observed is different.
The compiler is *allowed* to skip creation of a temporary and construct
the result of the right-hand side expression *directly* into the object
being constructed. Essentially, since the compiler sees the code for
all your functions, it can pass the reference to the constructed object
(in your case named 'i3') to the operator+ and inside the function
construct the actual 'i3' instead of 'xx'. No temporaries, no copies.
Is this any kind of optimization being performed by the compiler. Is
there anything that i am missing.
Yes, it is, and yes, you probably are.
I would appreciate if someone can explain this.
I hope I have.

V
--
Please remove capital 'A's when replying by e-mail
I do not respond to top-posted replies, please don't ask
Oct 9 '08 #2

P: n/a
On Oct 9, 5:59 pm, Victor Bazarov <v.Abaza...@comAcast.netwrote:
sanjay wrote:
I have a doubt in understanding the output of the following program
that i executed on my system. I was using DevC++ IDE which uses minGW
based compiler.
----------------------------------------------
#include <iostream>
using namespace std;
class Integer //: public DataType
{
private:
int x;
public:
Integer(int xx = 0);
Integer(const Integer&);
~Integer();
Integer operator+(const int i);
void operator=(const Integer& i);

As a side note, operator= *usually* returns a reference to the same
object. It's not required, of course.
};
Integer::Integer(int xx) : x(xx)
{
cout<<"Integer(int) x is "<<x<<endl;
}
Integer::Integer(const Integer& i) : x(i.x)
{
cout<<"Integer(Integer&)"<<endl;

You misrepresent the signature of your copy c-tor. The argument is a
reference to a const integer, so I'd expect the output statement to be

cout << "Integer(Integer const&)" << endl;

<g>
}
Integer::~Integer()
{
cout<<"~Integer()"<<endl;
}
Integer Integer::operator+(const int i)
{
cout<<"operator+ called i is "<<i<<endl;
Integer xx(x+i);
return xx;
}
void Integer::operator=(const Integer& i)
{
cout<<"operator= called i.x is "<<i.x<<endl;
x = i.x;
}
int main()
{
Integer i1(40);
Integer i3=i1+10; //Doubt understanding this
return 0;
}
-----------------------------------
Output:
Integer(int) x is 40
operator+ called i is 10
Integer(int) x is 50
~Integer()
~Integer()
-------------------------------------
I have a doubt in understanding the execution of operator+.
Inside operator+, xx is created and is returned by value. While
returning the copy-constructor of Integer should get invoked because
the output of operator+ is being assigned to i3 which is not yet
constructed, but the actual output observed is different.

The compiler is *allowed* to skip creation of a temporary and construct
the result of the right-hand side expression *directly* into the object
being constructed. Essentially, since the compiler sees the code for
all your functions, it can pass the reference to the constructed object
(in your case named 'i3') to the operator+ and inside the function
construct the actual 'i3' instead of 'xx'. No temporaries, no copies.
Is this any kind of optimization being performed by the compiler. Is
there anything that i am missing.

Yes, it is, and yes, you probably are.
I would appreciate if someone can explain this.

I hope I have.

V
--
Please remove capital 'A's when replying by e-mail
I do not respond to top-posted replies, please don't ask
Thanks...
Oct 9 '08 #3

This discussion thread is closed

Replies have been disabled for this discussion.