struct book
{
  book( const char* t, const char* a ) ;
  ~book() ; // required
  book( const book& that ) ; // required
  book& operator= ( const book& that ) ; // required
  char* title ;
  char* author ;
};
 
book::book( const char* t, const char* a )
{
  size_t title_len = strlen(t) ;
  title = new char[ title_len+1 ] ;
  strcpy( title, t ) ;
 
  size_t auth_len = strlen(a) ;
  author = new char[ auth_len+1 ] ; // this may fail (throw std::bad_alloc)
  // if it does, memory for title will leak. note: destructor of the book
  // being constructed will not (and should not) be called as the constructor
  // has not completed. so we have to scaffold this in a try/catch block.
  strcpy( author, a ) ;
}

struct foo { /* ... */ } ;
struct ebook : public book
{
  /*
  ...
  */
  foo* ptr ; // ebook 'owns' object pointed to by ptr
  ebook& operator= ( const ebook& that ) ; // implement this correctly
};

struct book
{
  book( const char* t, const char* a ) ;
  // compiler generated destructor, copy constructor, assignment
  std::string title ;
  std::string author ;
};
 
book::book( const char* t, const char* a ) : title(t), author(a)
{
  // constructor of author may fail (throw std::bad_alloc)
  // if it does, title, which has already been constructed will be
  // destroyed during the stack unwind; we have nothing to worry about.
}

struct foo { /* ... */ } ;
struct ebook : public book
{
  /*
  ...
  */
  some_owning_smart_ptr<foo> ptr ;
  ebook& operator= ( const ebook& that ) ;
};