Understanding Initialization Syntax

[joer3]

When you initialize a variable like this:

X var;
var = X();

The equals sign is called the assignment operator and you can overload
it and indeed should in many cases.

However, when you write code like this:

X var = X();

What is the equals sign considered? Is it still an operator? Can you
overload it? I can't imagine any reason why you would want to overload
it, just curious.

Also, it is my current understanding this is what happens under the
hood in these cases. Could someone confirm I understand correctly?

First Case:
1) Allocate memory for an "X" variable.
2) Call default constructor for "X" and put that in "var" (no copy
right?).
3) Call default constructor of "X" again and copy it to "var".
4) Delete temp data from second call to default constructor (not sure
when that happens).

Second Case:
1) Allocate memory for an "X" variable.
2) Call default constructor for "X" and put it in var.

Thanks,

Joe

[Noah Roberts]

Re: Understanding Initialization Syntax

joer3 wrote:

When you initialize a variable like this:
>
X var;
var = X();
>
The equals sign is called the assignment operator and you can overload
it and indeed should in many cases.
>
However, when you write code like this:
>
X var = X();
>
What is the equals sign considered? Is it still an operator? Can you
overload it? I can't imagine any reason why you would want to overload
it, just curious.

Copy constructor, it's easily overloaded, and you should be able to
think of many cases when you'd want to.

[joer3]

Re: Understanding Initialization Syntax

On Jul 21, 6:54 pm, Noah Roberts <u...@example.n etwrote:

joer3 wrote:

When you initialize a variable like this:

>

X var;
var = X();

>

The equals sign is called the assignment operator and you can overload
it and indeed should in many cases.

>

However, when you write code like this:

>

X var = X();

>

What is the equals sign considered? Is it still an operator? Can you
overload it? I can't imagine any reason why you would want to overload
it, just curious.

>
Copy constructor, it's easily overloaded, and you should be able to
think of many cases when you'd want to.

Sorry for being unclear but I get what a copy constructor is and what
it's used for. When I did a little test to better understand this, I
didn't get consistent results with your statement. This program:

#include <iostream>

using namespace std;

class My_Class
{
public:
My_Class ()
{
cout << "I'm Default\n";
}

My_Class (const My_Class&)
{
cout << "I'm Copy\n";
}

My_Class& operator=(const My_Class)
{
cout << "I'm Assignment\n";
return *this;
}
};

int main()
{
cout << "My_Class a = My_Class():\n";
My_Class a = My_Class();

cout << "\nMy_Class b = a:\n";
My_Class b = a;

cout << "\na=b\n";
a = b;

return 0;
}

I get:

My_Class a = My_Class():
I'm Default

My_Class b = a:
I'm Copy

a=b
I'm Copy
I'm Assignment
Press any key to continue . . .

I am guessing My_Class a = My_Class() doesn't call copy constructor
because the compiler is trying to optimize right (FAQ [10.9])? Maybe
if you could overload the "=" you could force it to call the copy
constructor or do something else (again why would you want to).

That brings me back to my original question, if the "=" isn't an
operator what is it and can you overload it?

[Victor Bazarov]

Re: Understanding Initialization Syntax

joer3 wrote:

[..] When I did a little test to better understand this, I
didn't get consistent results with your statement. This program:
>
#include <iostream>
>
using namespace std;
>
class My_Class
{
public:
My_Class ()
{
cout << "I'm Default\n";
}
>
My_Class (const My_Class&)
{
cout << "I'm Copy\n";
}
>
My_Class& operator=(const My_Class)
{
cout << "I'm Assignment\n";
return *this;
}
};
>
int main()
{
cout << "My_Class a = My_Class():\n";
My_Class a = My_Class();
>
cout << "\nMy_Class b = a:\n";
My_Class b = a;
>
cout << "\na=b\n";
a = b;
>
return 0;
}
>
I get:
>
My_Class a = My_Class():
I'm Default
>
My_Class b = a:
I'm Copy
>
a=b
I'm Copy
I'm Assignment
Press any key to continue . . .
>
I am guessing My_Class a = My_Class() doesn't call copy constructor
because the compiler is trying to optimize right (FAQ [10.9])?

Correct.

Maybe
if you could overload the "=" you could force it to call the copy
constructor or do something else (again why would you want to).
>
That brings me back to my original question, if the "=" isn't an
operator what is it and can you overload it?

(a) The '=' sign between the variable name and the initialiser in the
declaration statement is simply part of the syntax. It's not an
operator that you (or anybody else) can overload.

(b) There is no way to force a copy-constructor where it is allowed to
be forgone, using standard constructs. Perhaps you can do it using your
compiler's extensions/implementation-specific behaviours, but not using
any general language element.

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

[tony_in_da_uk@yahoo.co.uk]

Re: Understanding Initialization Syntax

On Jul 22, 8:31 am, joer3 <joery...@gmail .comwrote:

a=b
I'm Copy
I'm Assignment
Press any key to continue . . .

Note: you see both "I'm..." messages here because you forgot to make
the assignment operator take the right-hand-side value by reference.

I am guessing My_Class a = My_Class() doesn't call copy constructor
because the compiler is trying to optimize right (FAQ [10.9])?

Didn't check FAQ reference, but yeah.

Maybe
if you could overload the "=" you could force it to call the copy
constructor or do something else (again why would you want to).

Nope... this is one very special case where the language is allowed to
bypass your assignment operator to call the constructor: you can't
prevent this optimisation.

That brings me back to my original question, if the "=" isn't an
operator what is it and can you overload it?

As mentioned above, "=" can simply be an (arguably) more readable
notation for construction, but for efficiency and so that it can be
supported when no default constructor is available, the optimisation
mentioned above is explicitly allowed to the compiler.

Working backwards, I'll address some of your original questions:

However, when you write code like this:
X var = X();
What is the equals sign considered? Is it still an operator? Can you
overload it? I can't imagine any reason why you would want to overload
it, just curious.

The equals sign is just a part of the construction notation, and
doesn't constitute a call to the operator= member function.

Note too: X var = X() doesn't require creation of a separate X
instance that's then copied over or assigned into var: the (stack)
memory for var is simply and directly initialised as per the default
constructor.

Cheers,

Tony

[James Kanze]

Re: Understanding Initialization Syntax

On Jul 22, 12:44 am, joer3 <joery...@gmail .comwrote:

When you initialize a variable like this:

X var;
var = X();

The equals sign is called the assignment operator and you can
overload it and indeed should in many cases.

However, when you write code like this:

X var = X();

What is the equals sign considered?

Punctuation. In this case, it's not an operator, and can't be
overloaded.

Is it still an operator? Can you overload it? I can't imagine
any reason why you would want to overload it, just curious.

No and no.

Also, it is my current understanding this is what happens
under the hood in these cases. Could someone confirm I
understand correctly?

First Case:
1) Allocate memory for an "X" variable.
2) Call default constructor for "X" and put that in "var" (no copy
right?).
3) Call default constructor of "X" again and copy it to "var".

And copy assign it to var. There's an important difference:
copy assignment works on a fully constructed variable.

4) Delete temp data from second call to default constructor
(not sure when that happens).

The last two points would best be described as:

-- construct a temporary X using the default constructor,
-- copy assign it to var, using the assignment operator,
-- destruct the temporary.

Second Case:
1) Allocate memory for an "X" variable.
2) Call default constructor for "X" and put it in var.

Formally:
-- construct a temporary X using the default constructor,
-- copy it into var, using the copy constructor,
-- destruct the temporary
The standard explicitly authorizes the compiler to optimize out
the copy, however (and all that I know of do).

Your description would correspond to:
X var ;

--
James Kanze (GABI Software) email:james.kan ze@gmail.com
Conseils en informatique orientée objet/
Beratung in objektorientier ter Datenverarbeitu ng
9 place Sémard, 78210 St.-Cyr-l'École, France, +33 (0)1 30 23 00 34