new X vs new X()

[Razvan]

Hi !

Is there any difference between new X and new X() ?!

Regards,
Razvan

[Victor Bazarov]

Razvan wrote:

Is there any difference between new X and new X() ?!

There used to be, but only if X is a POD. The first form would
leave it uninitialised, the second would default-initialise it.

Nowadays I am not sure.

V

[Andrew Koenig]

"Razvan" <mi*****@mailci ty.com> wrote in message
news:15******** *************** **@posting.goog le.com...

Is there any difference between new X and new X() ?!

Yes, but it is very rare that you should care.

If you say "new X", the initial value of the object allocated is the same as
an uninitialized local variable of the same type would have. So, for
example, the result of "new int" is the address of an uninitialized int, and
the result of "new std::string" is the address of a std::string object with
no characters (because all strings are initialized, if only by the default
constructor). In contrast, the result of "new int()" is the address of an
int with value 0, and the result of "new std::string()" is exactly the same
as the result of "new std::string" (because all strings are initialized, if
only by the default constructor).

This is a relatively recent feature, so if you write a program that relies
on it, you may wish to make sure that your compiler implements it correctly.

[Rob Williscroft]

Victor Bazarov wrote in news:jB******** **********@dfw-read.news.verio .net
in comp.lang.c++:

Razvan wrote:

Is there any difference between new X and new X() ?!

There used to be, but only if X is a POD. The first form would
leave it uninitialised, the second would default-initialise it.

Nowadays I am not sure.

Nowadays its value-initialized, which is a kind-of recursive
default-intialization.

In 8.5/5

To value-initialize an object of type T means:

— if T is a class type (clause 9) with a user-declared
constructor (12.1), then the default constructor for T
is called (and the initialization is ill-formed if T
has no accessible default constructor);

— if T is a non-union class type without a user-declared
constructor, then every non-static data member and
base-class component of T is value-initialized;

8.5/7

An object whose initializer is an empty set of parentheses,
i.e., (), shall be value-initialized.

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

[Victor Bazarov]

Rob Williscroft wrote:

Victor Bazarov wrote in news:jB******** **********@dfw-read.news.verio .net
in comp.lang.c++:

Razvan wrote:

Is there any difference between new X and new X() ?!

There used to be, but only if X is a POD. The first form would
leave it uninitialised, the second would default-initialise it.

Nowadays I am not sure.

Nowadays its value-initialized, which is a kind-of recursive
default-intialization.

In 8.5/5

To value-initialize an object of type T means:

— if T is a class type (clause 9) with a user-declared
constructor (12.1), then the default constructor for T
is called (and the initialization is ill-formed if T
has no accessible default constructor);

— if T is a non-union class type without a user-declared
constructor, then every non-static data member and
base-class component of T is value-initialized;

8.5/7

An object whose initializer is an empty set of parentheses,
i.e., (), shall be value-initialized.

Thanks, Rob. So, in the case of 'new X', if X is a POD it is still
_uninitialised_ . The only difference now is that it's not "default-
initialised" for PODs but "value-initialised", right?

You don't have to reply, I'm just repeating here what Andrew Koenig's
reply stated (I hope).

Victor

[Rob Williscroft]

Victor Bazarov wrote in news:UC******** **********@dfw-read.news.verio .net
in comp.lang.c++:

Nowadays its value-initialized, which is a kind-of recursive
default-intialization.

In 8.5/5

To value-initialize an object of type T means:

- if T is a class type (clause 9) with a user-declared
constructor (12.1), then the default constructor for T
is called (and the initialization is ill-formed if T
has no accessible default constructor);

- if T is a non-union class type without a user-declared
constructor, then every non-static data member and
base-class component of T is value-initialized;

8.5/7

An object whose initializer is an empty set of parentheses,
i.e., (), shall be value-initialized.

Thanks, Rob. So, in the case of 'new X', if X is a POD it is still
_uninitialised_ . The only difference now is that it's not "default-
initialised" for PODs but "value-initialised", right?

You don't have to reply, I'm just repeating here what Andrew Koenig's
reply stated (I hope).

Ok :), but I will add that value-initialization isn't just for POD's,
it applies to any "non-union class type" without used defined
constructors.

#include <iostream>
#include <ostream>
#include <iomanip>
#include <vector>

struct X
{
std::vector< int > vi;
int x;
};

struct Y
{
std::vector< int > vi;
X x;
};

struct Z
{
std::vector< int > vi;
Y y;
};
void messitup()
{
int array[ 1000 ];
for ( int i = 0; i < 1000; ++i )
{
array[ i ] = 0xCCCCCCC;
}
}

bool is_vi()
{
Z z = Z();
return z.y.x.x == 0;
}

bool is_new_vi()
{
Z *z = new Z();
return z->y.x.x == 0;
}
int main()
{
messitup();

std::cout
<< "value-initialization: "
<< std::boolalpha << is_vi()
<< std::endl
;

std::cout
<< "fake-value-initialization: "
<< std::boolalpha << is_new_vi()
<< std::endl
;
}

1 out of 4 of my compilers returned true, true, 1 returned false, true.
I'm a bit dissapointed gcc 3.4 doesn't support this.

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

[JKop]

Victor Bazarov posted:

Razvan wrote:

Is there any difference between new X and new X() ?!

There used to be, but only if X is a POD. The first form would
leave it uninitialised, the second would default-initialise it.

Nowadays I am not sure.

V

What's a POD?
-JKop

[bartek]

JKop <NU**@NULL.NULL > wrote in news:u_******** *********@news. indigo.ie:

What's a POD?

http://www.parashift.com/c++-faq-lit....html#faq-26.7

[Razvan]

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

"Razvan" <mi*****@mailci ty.com> wrote in message
news:15******** *************** **@posting.goog le.com...

Is there any difference between new X and new X() ?!
Yes, but it is very rare that you should care.

If you say "new X", the initial value of the object allocated is the same as
an uninitialized local variable of the same type would have. So, for

This is valid only for the above mentioned POD type. For a
class the call new MyClass is the same with the call new MyClass()
(assuming the class has a default constructor). At least this is what
I understood from you and the previoud posters.

I am rewritting your expression: when calling new X (X is a POD
type) a new object X is created that it is not innitialized.

example, the result of "new int" is the address of an uninitialized int, and
the result of "new std::string" is the address of a std::string object with
no characters (because all strings are initialized, if only by the default
constructor). In contrast, the result of "new int()" is the address of an
int with value 0, and the result of "new std::string()" is exactly the same
as the result of "new std::string" (because all strings are initialized, if
only by the default constructor).
I see. For a POD (like an int) the call new int return a
pointer to an int that is not innitialized (it is not guaranteed to be
zero). OTOH new int() guarantees that the pointer points to an int
innitialized with zero.
For a string it does not matter how you create it because it
is a class that has a constructor and the constructor is called
anyway.

Bottom line:

int* pInt = new int; // the pointer points to an unnitialized int
int* pInt2 = new int() // the pointer points to an int that is
guaranteed to be innitialized to 0
MyClass tst = new MyClass;

is identical with:

MyClass tst2 = new MyClass();

This is a relatively recent feature, so if you write a program that relies
on it, you may wish to make sure that your compiler implements it correctly.

I see. Thanks for the advice.


Regards,
Razvan

[Andrew Koenig]

"Razvan" <mi*****@mailci ty.com> wrote in message
news:15******** *************** ***@posting.goo gle.com...

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

"Razvan" <mi*****@mailci ty.com> wrote in message
news:15******** *************** **@posting.goog le.com... If you say "new X", the initial value of the object allocated is the same as an uninitialized local variable of the same type would have. So, for This is valid only for the above mentioned POD type. For a
class the call new MyClass is the same with the call new MyClass()
(assuming the class has a default constructor). At least this is what
I understood from you and the previoud posters.
That is true, but it is also what I said. Please read it again. For
example:

class Foo { Foo(); /* whatever else you like */ };

In this case, the value of the expression "new Foo" is a pointer to an
object of type Foo that has the same value that an otherwise uninitialized
local variable of type Foo has, namely whatever value is obtained by running
the Foo constructor.
So I stand by my original statement.
I am rewritting your expression: when calling new X (X is a POD
type) a new object X is created that it is not innitialized.
This extra qualification is not necessary.
example, the result of "new int" is the address of an uninitialized int, and the result of "new std::string" is the address of a std::string object with no characters (because all strings are initialized, if only by the default constructor). In contrast, the result of "new int()" is the address of an int with value 0, and the result of "new std::string()" is exactly the same as the result of "new std::string" (because all strings are initialized, if only by the default constructor).

I see. For a POD (like an int) the call new int return a
pointer to an int that is not innitialized (it is not guaranteed to be
zero). OTOH new int() guarantees that the pointer points to an int
innitialized with zero.
Correct.
For a string it does not matter how you create it because it
is a class that has a constructor and the constructor is called
anyway.
Also correct.
Bottom line: int* pInt = new int; // the pointer points to an unnitialized int
int* pInt2 = new int() // the pointer points to an int that is
guaranteed to be innitialized to 0
MyClass tst = new MyClass;

is identical with:

MyClass tst2 = new MyClass();

Only if you have explicitly defined a constructor for MyClass.

Here is the interesting case:

struct Foo {
int i;
string s;
};

Now "new Foo" yields a pointer to a Foo object in which member s is empty
and member i is uninitialized, whereas "new Foo()" yields a pointer to a Foo
object in which member s is empty and member i is zero. Note that Foo is
not a POD type. Nevertheless, the behavior of "new Foo" differs from that
of "new Foo()".