Alf P. Steinbach wrote:
* Kai-Uwe Bux:
>Does the following have undefined behavior?
struct X;
struct Y {
X * x_ptr;
Y ( void )
: x_ptr ( 0 )
{}
~Y ( void ) {
delete x_ptr;
}
};
struct X {};
int main ( void ) {
Y y;
}
Note that struct X is defined after struct Y is defined but before a
variable of type Y is declared. I feel that it should depend on
when/where the destructor ~Y is instantiated; but the language in the
standard is frightening and I am not sure that, left to my own devices, I
would arrive at the commonly accepted interpretation.
I just note that Comeau gives a warning and g++ accepts the code without
complaint.
You can "delete" a pointer to incomplete type. But IIRC you have
Undefined Behavior if that type then defines a non-trivial destructor.
And that was the problem with Herb Sutter's original GOTW on the PIMPL
idiom, where he employed std::auto_ptr for the implementation object.
Thanks! You are refering to [5.3.4/5], right?
If the object being deleted has incomplete class type at the point of
deletion and the complete class has a non-trivial destructor or a
deallocation function, the behavior is undefined.
Now, the question becomes: which line in the program is the point of
deletion? I would think, in the snippet I posted, it's the line in the
destructor of Y, i.e., the following has UB:
#include <iostream>
#include <ostream>
struct X;
struct Y {
X * x_ptr;
Y ( X * ptr = 0 )
: x_ptr ( ptr )
{}
~Y ( void ) {
delete x_ptr;
}
};
struct X {
~X ( void ) {
std::cout << "crash me\n";
}
};
int main ( void ) {
Y y ( new X );
}
Thus, it makes perfect sense that it does not print anything with g++ :-)
However, I was more interested in templates anyway (posted an oversimplified
piece of code). So what about these:
A (typedef)
===========
#include <iostream>
#include <ostream>
template < typename X>
struct Y {
X * x_ptr;
Y ( X * ptr = 0 )
: x_ptr ( ptr )
{}
~Y ( void ) {
delete x_ptr;
}
};
struct X;
typedef Y<XYX;
struct X {
~X ( void ) {
std::cout << "crash me\n";
}
};
int main ( void ) {
YX yx ( new X );
}
B (inheritance)
===============
#include <iostream>
#include <ostream>
template < typename X>
struct Y {
X * x_ptr;
Y ( X * ptr = 0 )
: x_ptr ( ptr )
{}
~Y ( void ) {
delete x_ptr;
}
};
struct X;
struct YX : public Y<X{
YX ( X * ptr = 0 )
: Y<X>( ptr )
{}
};
struct X {
~X ( void ) {
std::cout << "crash me\n";
}
};
int main ( void ) {
YX yx ( new X );
}
C (position of function definition)
===================================
#include <iostream>
#include <ostream>
template < typename X>
struct Y {
X * x_ptr;
Y ( X * ptr = 0 )
: x_ptr ( ptr )
{}
~Y ( void ) {
delete x_ptr;
}
};
struct X;
void f ( X * ptr = 0 ) {
Y<Xy ( ptr );
}
struct X {
~X ( void ) {
std::cout << "crash me\n";
}
};
int main ( void ) {
f ( new X );
}
In my experiments with g++, all these programs print "crash me". Where is
the "point of deletion" in these programs when template instantiation
issues enter the picture? Which of the above have UB?
Best
Kai-Uwe Bux
