public:
 /**
  * Default constructor for the Media class
  */
 Media(void);
 /**
  * Copy constructor for the Media class
  *
  * @param audio Audio object
  */
 Media(const Media& media);
 /**
  * Returns the barcode of the current instance
  *
  * @returns barcode
  */
 const string& getBarcode(void) const;
 
 virtual string getMediaType(void) const = 0;
 
 /**
  * Returns the speed of the current instance
  *
  * @returns speed
  */
 const string& getSpeed(void) const;
 /**
  * Sets the barcode of the current instance
  *
  * @param barcode
  */
 void setBarcode(const string& barcode);
 /**
  * Sets the speed of the current instance
  *
  * @param speed
  */
 void setSpeed(const string& speed);
 /**
  * Compares the supplied parameter to the current instance
  *
  * @param obj Media object to compare to
  * @returns true if the current instance is the same as the supplied parameter
  */
 bool operator ==(const Media& obj) const;
 /**
  * Calls the operator== and returns its inverse
  *
  * @param media Media object to compare to
  * @returns true if the current instance is different to the supplied parameter
  */
 bool operator !=(const Media& media) const;
 
 virtual Media * createCopy(void) const = 0;
 /**
  * Reads in values of the instance variables from the console
  *
  * @returns 0 if the read worked, -1 if it failed
  */
 virtual int read(void);
 /**
  * Reads in values of the instance variables from a tokeniser object
  *
  * @param tok Tokeniser object
  * @returns 0 if the read worked, -1 if it failed
  */
 virtual int read(Tokeniser& tok);
 /**
  * Writes instance variables to the console
  *
  * @returns 0 if the write worked, -1 if it failed
  */
 virtual int write(void) const;
 /**
  * Writes instance variables to a file stream
  *
  * @param outf Output file stream
  * @returns 0 if the write worked, -1 if it failed
  */
 virtual int write(ofstream& outf) const = 0;

Entry::Entry(const Media& media, const Entertainment& entertainment)
{
 
  _media = media.createCopy();
  _entertainment =   entertainment.createCopy();
  Entry *entry;
  entry = new Entry(media, entertainment);
}

  Entry *entry;
  entry = new Entry(media, entertainment);

struct A
{
   int data;
   virtual void createCopy(const A & rhs) const = 0;
};
 
A a;   //error, cannot instantiate an object of type A since A is an abstract data type.
 
class B
{
   A a;  //error, cannot instantiate an object of type A even as a data member
};

class C : public A
{
    C() : data(0) {}
    C(int i) : data(i) {}
    void createCopy(const A & rhs) { data = rhs.data};
};
 
int main()
{
   A * pA;  //this is a pointer to type A, not an A object.  This is legal.
   C c(5);
   C c1;
   pA = &c1;
   pA->createCopy(c);  //copy data from c into c1 using the virtual function called createCopy() and the pointer to base class A, which happens to be abstract.  This is a pretty lame example, but I think it 
makes the point.  
}

class A
{
   int data;
 
   public:
   A(const A & rhs) 
   {
       createCopy(const A & rhs);
   }
   void getData() { return data};
   void createCopy(const A & rhs) {data = rhs.getData();}
};
 
class B
{
    //basically same a class A, don't make A or B abstract
};
 
class C
{
   A a;
   B b;
 
   public:
   A(const C & rhs)
   {
      if(isValid(rhs))
      {
        a.createCopy(rhs);
        b.createCopy(rhs);
      }
    }
    bool isValid(const C & rhs) { //whatever};
};

Entry::Entry(const Entry& entry):_media(NULL),_entertainment(NULL)
{

if(entry.isValid())
{
if ( entry._media != NULL )
{
_media = entry._media->createCopy();
}
if ( entry._entertainment != NULL )
{
_entertainment = entry._entertainment->createCopy();
}
}
}
Entry::Entry(const Media& media, const Entertainment& entertainment)
{
Entry entry;
if (entry.isValid())
{
_media = entry.getMedia()->createCopy();
_entertainment = entry.getEntertainment()->createCopy();
}

}