is there a difference between new MyClass; and new MyClass();?

[Mario Fratelli]

MyClass *p = new MyClass;
MyClass *p = new MyClass();

do they mean something different?

Thanks a lot,
Mario Fratelli.

[Moonlit]

Hi,

"Mario Fratelli" <si**@yahoo.com > wrote in message
news:e4******** *************** ***@posting.goo gle.com...

MyClass *p = new MyClass;
MyClass *p = new MyClass();

do they mean something different?
No, but note that:

MyClass p;
and
MyClass p();

does mean something different. The first is creating an object of MyClass.
The second is prototyping a function p() returning MyClass;
Regards, Ron AF Greve

Thanks a lot,
Mario Fratelli.

[Alf P. Steinbach]

On 7 Dec 2003 07:27:00 -0800, si**@yahoo.com (Mario Fratelli) wrote:

MyClass *p = new MyClass;
MyClass *p = new MyClass();

do they mean something different?

Yes, they do.

If MyClass is a POD (Plain Old Datastructure), roughly, no virtual
functions and no user-defined constructors, then with a standard-
conforming compiler the first statement creates a new instance without
initializing it, whereas the second gives default-initialization,
which for POD fields is zeroing.

If MyClass is not a POD then the two statements are equivalent.

[Andrew Koenig]

> MyClass *p = new MyClass;

MyClass *p = new MyClass();

do they mean something different?

Yes: In the first example, p points at an object that is
default-initialized; in the second case, p points at an object that is
value-initialized.

Default- and value-initialization differ only in the case where MyClass does
not have a user-defined constructor (although it might have data members of
classes that themselves have user-defined constructors). For example:

class MyClass {
public:
std::string name, address;
int postalcode;
};

In both examples above, the initial values of p->name and p->address will be
empty strings. However, in the first case, p->postalcode will be undefined,
whereas in the second case (p = new MyClass()), p->postalcode will be zero.

Note that this behavior is a change from C++98; many compilers do not yet
implement this behavior correctly.

[Rob Williscroft]

Mario Fratelli wrote in
news:e4******** *************** ***@posting.goo gle.com:

MyClass *p = new MyClass;
MyClass *p = new MyClass();

do they mean something different?

Yes, but only in the case where MyClass *doesn't* have any constructors,
particularly a default ctor.

If so in the second case, "value initialization" (IIRC) is used,
which means all of MyClass members are initialized by "value
initialization" , a recursive thing that ultimatly leads to the members
default constructors being called or in the case of inbuilt types
they are 0 initialized.

Note that for this to work all of MyClass 's members must have *no* user
defined constructors *or* they must also have a user defined default
constructor, this rule applies recusivly too.

example (simple):

class MyClass
{
public:

int i;
};

MyClass *initialized = new MyClass();
MyClass *not_initialize d = new MyClass;

intialized->i == 0;
not_intialized->i == /* un-initialized (AKA garbage) */;

not_intialized->i should be initialized before it is value is used or
the programme will exhibit undefined behaviour.

HTH.

Rob.
--
http://www.victim-prime.dsl.pipex.com/

[Victor Bazarov]

"Moonlit" <al******@jupit er.universe> wrote...

"Mario Fratelli" <si**@yahoo.com > wrote in message
news:e4******** *************** ***@posting.goo gle.com...

MyClass *p = new MyClass;
MyClass *p = new MyClass();

do they mean something different?
No

Wrong. Depending on the 'MyClass', there may be a difference.
, but note that:

MyClass p;
and
MyClass p();

does mean something different. The first is creating an object of MyClass.
The second is prototyping a function p() returning MyClass;
Regards, Ron AF Greve

Thanks a lot,
Mario Fratelli.

[Mario Fratelli]

"Andrew Koenig" <ar*@acm.org> wrote in message news:<P1******* *************** *@bgtnsc04-news.ops.worldn et.att.net>...

Note that this behavior is a change from C++98; many compilers do not yet
implement this behavior correctly.

since the behaviour is differente only when you don't have default
constructors, how can I test the compiler?

Mario Fratelli.

[Victor Bazarov]

"Mario Fratelli" <si**@yahoo.com > wrote...

"Andrew Koenig" <ar*@acm.org> wrote in message

news:<P1******* *************** *@bgtnsc04-news.ops.worldn et.att.net>...

Note that this behavior is a change from C++98; many compilers do not yet implement this behavior correctly.

since the behaviour is differente only when you don't have default
constructors, how can I test the compiler?

It's rather difficult. It would involve using an uninitialised values
of POD, which in itself can cause undefined behaviour.

But try this:

struct A {
int a;
};
#include <iostream>
int main() {
char *storage = new char[sizeof(A)];
for (int i = 0; i < sizeof(A); ++i)
storage[i] = 1;
A *pa = new (storage) A;
std::cout << pa->a << std::endl;
pa = new (storage) A();
std::cout << pa->a << std::endl;
delete[] storage;
}

If you get two zeroes as output, your compiler value-initialises
PODs when it is supposed to leave it uninitialised.

Make sure to build a release version as debug ones often initialise
values to 0 without your specific actions.

Victor

P.S. I tested this with VC++ v6sp5 (and it failed to default-
initialise the 'A' the second time) and with Intel C++ v4.5, which
gave the expected output:

16843009
0

(well, the first value is not something specifically expected, just
so it is not 0)

[Moonlit]

"Victor Bazarov" <v.********@com Acast.net> wrote in message
news:rcJAb.4578 99$Fm2.450221@a ttbi_s04...

"Moonlit" <al******@jupit er.universe> wrote...

"Mario Fratelli" <si**@yahoo.com > wrote in message
news:e4******** *************** ***@posting.goo gle.com...

MyClass *p = new MyClass;
MyClass *p = new MyClass();

do they mean something different?
No

Wrong. Depending on the 'MyClass', there may be a difference.

Oops, your right.

Sorry for my bad advice :-(

, but note that:

MyClass p;
and
MyClass p();

does mean something different. The first is creating an object of MyClass. The second is prototyping a function p() returning MyClass;
Regards, Ron AF Greve

Thanks a lot,
Mario Fratelli.

[Alf P. Steinbach]

On Sun, 07 Dec 2003 15:53:16 GMT, al***@start.no (Alf P. Steinbach) wrote:

On 7 Dec 2003 07:27:00 -0800, si**@yahoo.com (Mario Fratelli) wrote:

MyClass *p = new MyClass;
MyClass *p = new MyClass();

do they mean something different?

Yes, they do.

If MyClass is a POD (Plain Old Datastructure), roughly, no virtual
functions and no user-defined constructors, then with a standard-
conforming compiler the first statement creates a new instance without
initializing it, whereas the second gives default-initialization,
which for POD fields is zeroing.

If MyClass is not a POD then the two statements are equivalent.

Among 112 spams and Swen viruses a mail from Andrew Koenig, almost deleted
in my spam-removal frenzy, pointing my attention to that last sentence.

Ooops.

And thanks, Andrew.

While the sentence holds wrt. C++ 1998, the C++ 2003 standard revision changed
the rules slightly. The relevant paragraps are §5.3.4/15, which defines the
effect with and without "()", and §8.5/5, which defines the terms
"zero-initialization" , "default-initialization" and, in C++ 2003, the new term
"value-initialization" . In C++ 2003, the 'new' statement with "()" gives
value-initialization, which is not necessarily equivalent to
default-initialization: roughly, value-initialization only calls the default
constructor if it is a user-defined constructor, and otherwise gives
zero-initialization. So "()" can no longer be read as "call constructor".

The upshot is that in C++ 2003 you're guaranteed zero-initialization in at
least one more case than in C++ 1998, namely in the case of "new T()" where T
is non-POD and does not have a user-defined constructor.

This language keeps getting subtler and subtler.