471,089 Members | 1,548 Online
Bytes | Software Development & Data Engineering Community
Post +

Home Posts Topics Members FAQ

Join Bytes to post your question to a community of 471,089 software developers and data experts.

Early dynamic initialization permitted for local statics?

I've seen this question raised more than once, but I have not yet seen
a definite, conclusive answer. Consider the following code:

struct C {
C() {} // might throw
};

int main() {
try {
static C c;
}
catch(...) {
//...
}
}

Now according to 6.7/4:
"(...) An implementation is permitted to perform early initialization
of other local objects with static storage duration under the same
conditions that an implementation is permitted to statically
initialize an object with static storage duration in namespace scope
(3.6.2).(...)"

Are the following statements correct?
1)
An implementation may perform early initialization of c, possibly
resulting in an uncaught exception.

2)
Early initialization can be prevented by making C::C() modify an
arbitrary object of namespace scope with static storage duration, per
3.6.2/2

Thanks in advance.
DP
Jun 27 '08 #1
5 1819
Triple-DES wrote:
I've seen this question raised more than once, but I have not yet
seen a definite, conclusive answer. Consider the following code:

struct C {
C() {} // might throw
};

int main() {
try {
static C c;
}
catch(...) {
//...
}
}

Now according to 6.7/4:
"(...) An implementation is permitted to perform early
initialization of other local objects with static storage duration
under the same conditions that an implementation is permitted to
statically initialize an object with static storage duration in
namespace scope (3.6.2).(...)"
This talks about statically initializing with a constant expression.
As your example involves a constructor, this is more likely a dynamic
initlialization.

The static keyword doesn't help. :-)
>
Are the following statements correct?
1)
An implementation may perform early initialization of c, possibly
resulting in an uncaught exception.
I don't think so.
>
2)
Early initialization can be prevented by making C::C() modify an
arbitrary object of namespace scope with static storage duration,
per
3.6.2/2
No.
The other question is why you need a static variable inside main()?!
As main can only be called once, there is little risk of initializing
the local variable more than once.

Bo Persson

Jun 27 '08 #2
On 28 Mai, 20:09, "Bo Persson" <b...@gmb.dkwrote:
Triple-DES wrote:
struct C {
*C() {} // might throw
};
int main() {
*try {
* *static C c;
*}
*catch(...) {
* //...
*}
}
Now according to 6.7/4:
"(...) An implementation is permitted to perform early
initialization of other local objects with static storage duration
under the same conditions that an implementation is permitted to
statically initialize an object with static storage duration in
namespace scope (3.6.2).(...)"

This talks about statically initializing with a constant expression.
As your example involves a constructor, this is more likely a dynamic
initlialization.
Sure, I have considered that interpretation. But see for instance this
thread:
http://groups.google.com/group/comp....9a16407c86419a

Notably, the comment by Francis W. Glassborow:
(...)And I would much prefer that it was not allowed to do dynamic
initialisation early, not least because of implications on exception
safety.(...)
The static keyword doesn't help. *:-)
[snip]
The other question is why you need a static variable inside main()?!
As main can only be called once, there is little risk of initializing
the local variable more than once.
That's just to illustrate the problem.

DP
Jun 27 '08 #3
Triple-DES wrote:
>I've seen this question raised more than once, but I have not yet
seen a definite, conclusive answer. Consider the following code:

struct C {
C() {} // might throw
};

int main() {
try {
static C c;
}
catch(...) {
//...
}
}
Interestingly, if:

void f() {
static C aC;
/* ... */
}

If the ctor throws an exception, when f called the second time, C ctor
is called again. At least in my implementation.

Is this behavior specified in the standard and can I rely on it ?
Jun 27 '08 #4
On 29 Mai, 07:38, Irin Kotchencko <ikotchen...@gmail.comwrote:
Interestingly, if:

void f() {
* * static C aC;
* * /* ... */

}

If the ctor throws an exception, when f called the second time, C ctor
is called again. At least in my implementation.

Is this behavior specified in the standard and can I rely on it ?
Yes, this is also specified in 6.7/4:
"(...)If the initialization exits by throwing an exception, the
initialization is not complete, so it will be tried again next time
control enters the declaration(...)"

DP
Jun 27 '08 #5
On 29 Mai, 07:38, Irin Kotchencko <ikotchen...@gmail.comwrote:
>Interestingly, if:

void f() {
static C aC;
/* ... */

}

If the ctor throws an exception, when f called the second time, C ctor
is called again. At least in my implementation.

Is this behavior specified in the standard and can I rely on it ?

Yes, this is also specified in 6.7/4:
"(...)If the initialization exits by throwing an exception, the
initialization is not complete, so it will be tried again next time
control enters the declaration(...)"

DP
thank you
Jun 27 '08 #6

This discussion thread is closed

Replies have been disabled for this discussion.

Similar topics

4 posts views Thread by Cheng Mo | last post: by
4 posts views Thread by Bret Pehrson | last post: by
8 posts views Thread by Alexander Stippler | last post: by
13 posts views Thread by xian_hong2046 | last post: by
10 posts views Thread by utab | last post: by
24 posts views Thread by Eric | last post: by
20 posts views Thread by JohnQ | last post: by

By using Bytes.com and it's services, you agree to our Privacy Policy and Terms of Use.

To disable or enable advertisements and analytics tracking please visit the manage ads & tracking page.