Is the following code legal?

[Kiuhnm]

#include <new>

class T
{
};

int main()
{
T t = t;
T u(u);
T v;
new (&v) T(v);
}

Kiuhnm

[Ben Pope]

Kiuhnm wrote:

#include <new>

class T
{
};

int main()
{
T t = t;
T u(u);
T v;
new (&v) T(v);
}

Kiuhnm

Have you tried compiling this?

Does you compiler give you errors?

Why do you think that is?

What do you expect each line to do?

Ben Pope
--
I'm not just a number. To many, I'm known as a string...

[Kiuhnm]

Ben Pope ha scritto:

Have you tried compiling this?
Yes, but it is irrelevant. How can I be sure that my compiler is
completely standard-compliant?
What do you expect each line to do?

It is irrelevant.
All I would like to know is whether the code, according to the standard,
produces a defined behavior or not.

Kiuhnm

[Rolf Magnus]

Kiuhnm wrote:

Ben Pope ha scritto:

Have you tried compiling this?

Yes, but it is irrelevant. How can I be sure that my compiler is
completely standard-compliant?

You can't.

What do you expect each line to do?

It is irrelevant.
All I would like to know is whether the code, according to the standard,
produces a defined behavior or not.

Not.

[Daniel T.]

In article <44************ ***********@rea der1.news.tin.i t>,
Kiuhnm <"kiuhnm03["@]yahoo.it> wrote:

Ben Pope ha scritto:

Have you tried compiling this?

Yes, but it is irrelevant. How can I be sure that my compiler is
completely standard-compliant?

What do you expect each line to do?

It is irrelevant.
All I would like to know is whether the code, according to the standard,
produces a defined behavior or not.

T t = t;
T u(u);

The above two lines will compile but the behavior is undefined.
T v;
new (&v) T(v);

The above two lines produce defined behavior.

Please, why do you ask?
--
Magic depends on tradition and belief. It does not welcome observation,
nor does it profit by experiment. On the other hand, science is based
on experience; it is open to correction by observation and experiment.

[Kiuhnm]

Rolf Magnus ha scritto:

Not.

Why?
I read 3.3.1 and 3.8 in the c++ iso, but that did not clarify my doubts.

Kiuhnm

[Kiuhnm]

Daniel T. ha scritto:

T t = t;
T u(u);

The above two lines will compile but the behavior is undefined.
And what about
int x = x;
?
Please, why do you ask?

I am just curious.

Kiuhnm

[Victor Bazarov]

Kiuhnm" <"kiuhnm03[ wrote:

Daniel T. ha scritto:

T t = t;
T u(u);

The above two lines will compile but the behavior is undefined.

And what about
int x = x;
?

What's the difference from

T t = t;

do you see here?

V
--
Please remove capital As from my address when replying by mail

[Dietmar Kuehl]

Kiuhnm wrote:

#include <new>

class T
{
};

int main()
{
T t = t;
T u(u);
T v;
new (&v) T(v);
}

What is your particular question anyway? What do you suspect to be
illegal and why? The obvious violation is double construction of an
object which is illegal. However, you put other stuff into the
article, too, which might indicate that you are actually looking for
other sources of "illegal code".
--
<mailto:di***** ******@yahoo.co m> <http://www.dietmar-kuehl.de/>
<http://www.eai-systems.com> - Efficient Artificial Intelligence

[AnalogFile]

Dietmar Kuehl wrote:

Kiuhnm wrote:

#include <new>

class T
{
};

int main()
{
T t = t;
T u(u);
T v;
new (&v) T(v);
}
What is your particular question anyway?

He is asking because we have been discussing that in our national C++
newsgroup but did not come to a definitive conclusion.

There are more variations on the same theme and they may or may not
change the validity of those constructs.
What do you suspect to be
illegal and why?
It depends who you ask to. If we had any consensus we would not even ask.

For as much as we can say the placement new construct is perfectly defined.

That is:

void foo()
{
class T {} v;
new (&v) T(v);
}

is perfectly legal.
The obvious violation is double construction of an
object which is illegal.
Not. The standard does not say you cannot construct twice. And does not
guarantee that the number of constructions matches the number of
destructions. If you reuse the memory of a live object, that object
lifetime ends without the construction being called and it is explicitly
legal to do so. See 3.8#4
However, you put other stuff into the
article, too, which might indicate that you are actually looking for
other sources of "illegal code".

In fact 3.8 is no help in the other cases.

We know that

struct T {
void *p;
T(){}
T(T*pp){ p=pp; if (pp==this) cout << "wow!\n"; }
};

void foo()
{
T t=&t;
T u(&u);
}

is perfectly defined (see 3.3.1#1 and 3.8#5)

But the wording in 3.8, specifically the first item of the list in
3.8#5, together with 3.8#1 seem to imply that

struct T {
int i;
T(){}
T(const T&r){i=r.i;}
};

void foo()
{
T t=t;
T u(u);
}

is undefined behavior (cannot access r.i until the lifetime has begun,
and that happens at the end of the constructor).

And this is apparently incongruous with the fact that

void foo()
{
int i=i;
int j(j);
}

is perfectly valid as in 3.3.1#1