slicing copy, what's wrong with abstract class?

[baibaichen]

i have written some code to verify how to disable slicing copy
according C++ Gotchas item 30

the follow is my class hierarchy, and note that B is abstract class!!

class B
{
public:
explicit B(INT32 i =0):i_(i){}
virtual ~B(){}
virtual void do_it() = 0;
virtual void pay() const = 0;
protected:
private:
INT32 i_;
};

class D: public B
{
public:
explicit D(INT32 j=0):B(),j_(j){ }
virtual void do_it()
{
j_ = 100;
}
virtual void pay() const {}
protected:
private:
INT32 j_;
};

accring to book, the following code can not be compiled, however it can
be compiled in the vc7.1

D d,d1(1);
B *const pb=&d1;
*pb = d; // B is abstract class, and this should be issued a compile
error according to the book
// however it can be compiled in the vc7.1

what's something with me or the book?

thanks

[Earl Purple]

baibaichen wrote:

i have written some code to verify how to disable slicing copy
according C++ Gotchas item 30

the follow is my class hierarchy, and note that B is abstract class!!

class B
{
public:
explicit B(INT32 i =0):i_(i){}
virtual ~B(){}
virtual void do_it() = 0;
virtual void pay() const = 0;
protected:
private:
INT32 i_;
};

class D: public B
{
public:
explicit D(INT32 j=0):B(),j_(j){ }
virtual void do_it()
{
j_ = 100;
}
virtual void pay() const {}
protected:
private:
INT32 j_;
};

accring to book, the following code can not be compiled, however it can
be compiled in the vc7.1

D d,d1(1);
B *const pb=&d1;
*pb = d; // B is abstract class, and this should be issued a compile
error according to the book
// however it can be compiled in the vc7.1

I don't have the book but are you sure that's what it says? Why
shouldn't it compile, operator= is public in B. Make it protected and
it won't compile but you'll still be able to assign D.
what's something with me or the book?

thanks

[Axter]

baibaichen wrote:

i have written some code to verify how to disable slicing copy
according C++ Gotchas item 30

the follow is my class hierarchy, and note that B is abstract class!!

class B
{
public:
explicit B(INT32 i =0):i_(i){}
virtual ~B(){}
virtual void do_it() = 0;
virtual void pay() const = 0;
protected:
private:
INT32 i_;
};

class D: public B
{
public:
explicit D(INT32 j=0):B(),j_(j){ }
virtual void do_it()
{
j_ = 100;
}
virtual void pay() const {}
protected:
private:
INT32 j_;
};

accring to book, the following code can not be compiled, however it can
be compiled in the vc7.1

D d,d1(1);
B *const pb=&d1;
*pb = d; // B is abstract class, and this should be issued a compile
error according to the book
// however it can be compiled in the vc7.1

what's something with me or the book?

To my knowledge, there is no way to avoid slicing with abstract logic.

With concrete types, you can avoid slicing by making your class
non-copyable.
This can be done by making the copy constructor and assignment operator
private, and with no implementation.
But this method will not work on abstract types.
Moreover, if you're passing raw pointers, you shouldn't get any
slicing.
With abstract pointers, you can get slicing when using smart pointers
that have clone logic.

[Earl Purple]

Axter wrote:

To my knowledge, there is no way to avoid slicing with abstract logic.
Didn't you read my above post? I just showed how it can be done.
With concrete types, you can avoid slicing by making your class
non-copyable.
This can be done by making the copy constructor and assignment operator
private, and with no implementation.
But this method will not work on abstract types.
No but you can make copying and copy-construction protected. That
prevents slicing whilst allowing the derived classes to have copy and
assignment semantics.
Moreover, if you're passing raw pointers, you shouldn't get any
slicing.
With abstract pointers, you can get slicing when using smart pointers
that have clone logic.

No doubt yet another case for the Axter clone-pointer.

[Axter]

Earl Purple wrote:

Axter wrote:

To my knowledge, there is no way to avoid slicing with abstract logic.
Didn't you read my above post? I just showed how it can be done.

That can only prevent slicing using value semantics. It can not
prevent slicing using pointer semantics.

With concrete types, you can avoid slicing by making your class
non-copyable.
This can be done by making the copy constructor and assignment operator
private, and with no implementation.
But this method will not work on abstract types.

No but you can make copying and copy-construction protected. That
prevents slicing whilst allowing the derived classes to have copy and
assignment semantics.

Again, that does not prevent slicing in pointer semantics. Only for
value semantics.

Moreover, if you're passing raw pointers, you shouldn't get any
slicing.
With abstract pointers, you can get slicing when using smart pointers
that have clone logic.

No doubt yet another case for the Axter clone-pointer.

Sorry to say, but even my clone smart pointer does not prevent slicing.
Although it has assert logic for slicing, that will only catch the
slicing at runtime, and will not prevent it from compiling.

I have not found any method that can stop slicing for abstract types at
compile time.

[Stephan Brönnimann]

Axter wrote:
[snip]

I have not found any method that can stop slicing for abstract types at
compile time.

For my understanding: could you please show how in the
following code Base can be sliced?
class Base {
public:
Base(int i = 0);
virtual ~Base();
protected:
Base(const Base& rhs);
Base& operator=(const Base& rhs);

private:
int i_;
};

Regards, Stephan

[Axter]

Stephan Brönnimann wrote:

Axter wrote:
[snip]

I have not found any method that can stop slicing for abstract types at
compile time.

For my understanding: could you please show how in the
following code Base can be sliced?
class Base {
public:
Base(int i = 0);
virtual ~Base();
protected:
Base(const Base& rhs);
Base& operator=(const Base& rhs);

private:
int i_;
};

FYI: Your example ahs the private and protected in reverse location.

In order to copy an abstract type, you have to use a clone method
similar to that used by boost pointer containers, or a clone method
similar to the one used by the following clone smart pointer:
http://code.axter.com/copy_ptr.h

Both method can get sliced even when base class has private copy
constructor and assignment operator.

The following example code is pulled from a recent thread in the boost
newsgroup.

class BasesS1
{
public:
virtual BasesS1* do_clone()const =0;
virtual string WhoAmI()const=0 ;
BasesS1(int i = 0):m_i(i){}
private:
BasesS1( const BasesS1& );
BasesS1& operator=( const BasesS1& );
protected:
int m_i;
};

class DerivedS1 : public BasesS1
{
public:
DerivedS1(int i = 0):BasesS1(i){}
BasesS1* do_clone()const {return new DerivedS1();}
string WhoAmI()const{r eturn "DerivedS1" ;}
};

class DerivedDerivedS 1 : public DerivedS1
{
public:
DerivedDerivedS 1(int i = 0):DerivedS1(i) {}
string WhoAmI()const{r eturn "DerivedDerived S1";}
};

void somefunction()
{
boost::ptr_vect or<BasesS1> vBaseS1_cpy1;
vBaseS1_cpy1.pu sh_back(new DerivedDerivedS 1(123));
boost::ptr_vect or<BasesS1> vBaseS1_cpy2(vB aseS1_cpy1.begi n(),
vBaseS1_cpy1.en d());
cout << vBaseS1_cpy2[0].WhoAmI() << endl;
}

The above code will produce slicing, even though the base class has
private copy constructor and assignment operator.

[Earl Purple]

Axter wrote:

Stephan Brönnimann wrote:

For my understanding: could you please show how in the
following code Base can be sliced?
class Base {
public:
Base(int i = 0);
virtual ~Base();
protected:
Base(const Base& rhs);
Base& operator=(const Base& rhs);

private:
int i_;
};
FYI: Your example ahs the private and protected in reverse location.

No it doesn't.
The following example code is pulled from a recent thread in the boost
newsgroup.

class BasesS1
{
public:
virtual BasesS1* do_clone()const =0;
virtual string WhoAmI()const=0 ;
BasesS1(int i = 0):m_i(i){}
private:
BasesS1( const BasesS1& );
BasesS1& operator=( const BasesS1& );
protected:
int m_i;
};

class DerivedS1 : public BasesS1
{
public:
DerivedS1(int i = 0):BasesS1(i){}
BasesS1* do_clone()const {return new DerivedS1();}
string WhoAmI()const{r eturn "DerivedS1" ;}
};

class DerivedDerivedS 1 : public DerivedS1
{
public:
DerivedDerivedS 1(int i = 0):DerivedS1(i) {}
string WhoAmI()const{r eturn "DerivedDerived S1";}
};

1. DerivedS1 is not abstract. The problem was to prevent an ABSTRACT
base-class from being sliced, which can be done by giving it a
protected copy-constructor and protected assignment.

2. Your derived class is implementing the copying of the base class
because the base-class has left in a loophole, i.e. making its members
protected.

3. If you don't write the derived class properly it won't work, i.e. if
you overload the copy-constructor to not actually copy any of its
members. Why would you do that though?

4. You didn't answer the above poster's question.

[Axter]

Earl Purple wrote:

Axter wrote:

Stephan Brönnimann wrote:

For my understanding: could you please show how in the
following code Base can be sliced?
class Base {
public:
Base(int i = 0);
virtual ~Base();
protected:
Base(const Base& rhs);
Base& operator=(const Base& rhs);

private:
int i_;
};

FYI: Your example ahs the private and protected in reverse location.

No it doesn't.

The following example code is pulled from a recent thread in the boost
newsgroup.

class BasesS1
{
public:
virtual BasesS1* do_clone()const =0;
virtual string WhoAmI()const=0 ;
BasesS1(int i = 0):m_i(i){}
private:
BasesS1( const BasesS1& );
BasesS1& operator=( const BasesS1& );
protected:
int m_i;
};

class DerivedS1 : public BasesS1
{
public:
DerivedS1(int i = 0):BasesS1(i){}
BasesS1* do_clone()const {return new DerivedS1();}
string WhoAmI()const{r eturn "DerivedS1" ;}
};

class DerivedDerivedS 1 : public DerivedS1
{
public:
DerivedDerivedS 1(int i = 0):DerivedS1(i) {}
string WhoAmI()const{r eturn "DerivedDerived S1";}
};

1. DerivedS1 is not abstract. The problem was to prevent an ABSTRACT
base-class from being sliced, which can be done by giving it a
protected copy-constructor and protected assignment.

2. Your derived class is implementing the copying of the base class
because the base-class has left in a loophole, i.e. making its members
protected.

3. If you don't write the derived class properly it won't work, i.e. if
you overload the copy-constructor to not actually copy any of its
members. Why would you do that though?

4. You didn't answer the above poster's question.

I did answer the question. Abstract types can not be duplicated
directly, and must use an alternate interface like that used by boost
pointer containers or the copy_ptr.
Regardless of which method you use to copy an abstract type, it can get
slice, even with non-copyable base class.

In this thread, the purpose of making the base class non-copyable is to
stop slicing at compile time, and more specifically, to stop erroneous
slicing code from compiling. Making the base class non-copyable does
not stop erroneous abstract slicing from compiling.

Since this question is specifically referring to an abstract class,
this is more relevant.

[Axter]

Earl Purple wrote:

Axter wrote:

Stephan Brönnimann wrote:

For my understanding: could you please show how in the
following code Base can be sliced?
class Base {
public:
Base(int i = 0);
virtual ~Base();
protected:
Base(const Base& rhs);
Base& operator=(const Base& rhs);

private:
int i_;
};

FYI: Your example ahs the private and protected in reverse location.

No it doesn't.

The following example code is pulled from a recent thread in the boost
newsgroup.

class BasesS1
{
public:
virtual BasesS1* do_clone()const =0;
virtual string WhoAmI()const=0 ;
BasesS1(int i = 0):m_i(i){}
private:
BasesS1( const BasesS1& );
BasesS1& operator=( const BasesS1& );
protected:
int m_i;
};

class DerivedS1 : public BasesS1
{
public:
DerivedS1(int i = 0):BasesS1(i){}
BasesS1* do_clone()const {return new DerivedS1();}
string WhoAmI()const{r eturn "DerivedS1" ;}
};

class DerivedDerivedS 1 : public DerivedS1
{
public:
DerivedDerivedS 1(int i = 0):DerivedS1(i) {}
string WhoAmI()const{r eturn "DerivedDerived S1";}
};

1. DerivedS1 is not abstract. The problem was to prevent an ABSTRACT
base-class from being sliced,

Base class don't get slice. It's derive classes that get slice. The
example shows a derived class getting slice.