Re: where does slicing produce UB?
On May 28, 12:32 pm, Frank Birbacher <bloodymir.c...@gmx.net> wrote:
Hi!
In a recent post about type safety there was code similar to the
following:
struct B {
virtual ~B() {}
int v;
};
struct D : B {
double d;
}
void slice()
{
auto_ptr<B> b(new D);
B b2;
b2 = *b; //UB??
B b3 = *b; //UB??
}
does any of the above code invoke undefined behaviour? Can slicing ever
invoke UB? Yes, your own op= or copy ctor may introduce UB, but how
about the "non obvious" cases?
I recently used slicing of a non polymorphic struct on purpose and I
wonder why I shouldn't use it.
Frank
Perhaps a better example would suffice:
struct B{
B(unsigned a):data(a){valid();}
B& operator=(B const&r){
data=r.data;
return *this;
}
virtual ~B(){}
virtual void validate(){
valid();
}
protected:
void valid(){
if(data>10)throw 1;
}
unsigned get()const{
return data;
}
private:
unsigned data;
};
struct D:B{
D( unsigned t, unsigned u):B(t),data2(u){
validate();
}
unsigned get2()const{
return data2;
}
D& operator=(D const&r){
B::operator=(r);
data2=r.data2;
return *this;
}
void validate(){
valid();
if((data2+get()>15))throw 2;
}
private:
unsigned data2;
};
void foo(){
auto_ptr<B> b(new D(9,1));
b->validate();//OK
auto_ptr<B> b2(new D(1,10));
b2->validate();//OK
*b2=*b;
b2->validate();//BOOM!!!
D const& d=dynamic_cast<D const&>(*b2);
if(d.get()==9 && d.get2()==10)
cout<<"UDB";
}
I could have just taken out the polymorphic stuff, and just wrote
assertions using get() and get2() and static_cast, and illustrated the
same thing.
The point is that slicing does not change the objects "type" as far as
the symbol table and RTTI and object layout is concerned, however, it
is not longer a D object in terms of the invariants it preserves. Just
what the correct term is for the type of object D is (not a zombie,
that is something else) I don't know.
Using polymorphism and pimpls it is possible to build a type that does
not slice:
virtual B_impl* clone()=0;
and a B that wraps B_impl and does the obvious stuff. But this is not
done in practice that often because of the overhead involved.
And object that does not preserve it own invariants is a good way to
get UDB. Mind you, the compiler and C++ runtimes are perfectly happy,
so the program is well formed in that regard. However, few would agree
that the program as a whole is well formed.
Lance
--
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]