sanjay
10/9/2008 1:17:00 PM
On Oct 9, 5:59 pm, Victor Bazarov <v.Abaza...@comAcast.net> wrote:
> 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...