Copy constructor for derived class from base pointer

Question

I have looked all around and can't find the answer to my question anywhere. I am trying to use a copy constructor of a derived class from a pointer array of base classes. The only thing I have learned is I should probably use dynamic_cast but cant get that working.

This is the important parts of my code so far (original is way to big since I have 16 different files but this should be enough).

EDIT: The error I receive doing it this way is |26|error: cannot dynamic_cast '& properties[0]' (of type 'class Property**') to type 'class Commercial*' (source is not a pointer to class)|

#include "rentals.h"
#include "commercial.h"
#include "sales.h"
#include "comSales.h"
#include "resSales.h"
#include "resRentals.h"
#include "comRentals.h"

const int MAX_PROPERTIES = 5;

int main(void) {
   int i;


   Property *properties[MAX_PROPERTIES];


   properties[0] = new Commercial("Notting Hill McDonalds", "4 Gardiner Road",
                                  "Notting Hill", 5000, "Li3000");


   properties[1] = new ResRentals("Janet Dalgleish", "30 Firhill Court",
                           "Mary Hill", 4000, 500.00, 300.00, 4);


   properties[2] = new Commercial(dynamic_cast<Commercial*>(properties[0]));  // <-- the copy constructor I can not get to work.


   delete[] properties;

   return 0;
}

commercial.cpp file

#include "property_a.h"
#include "commercial.h"


Commercial::Commercial() : Property() {
   owner = "NULL";
   address = "NULL";
   suburb = "NULL";
   postcode = 0;
   license = "NULL";
}

Commercial::Commercial(string theOwner, string theAddress,
                        string theSuburb, int thepostCode,
                        string theLicense): Property(theOwner, theAddress,
                        theSuburb, thepostCode), license(theLicense) {}

Commercial::~Commercial() {}

Commercial::Commercial(const Commercial& orig) : Property(orig),
                        license(orig.getLicense()) {}

void Commercial::print() {
   cout << getOwner() << endl;
   cout << getAddress() << endl;
   cout << getSuburb() << endl;
   cout << getPostcode() << endl;
   cout << getLicense() << endl;
}

commercial.h file

#ifndef __COMMERCIAL_H__
#define __COMMERCIAL_H__


#include "property_a.h"

class Commercial :  public virtual Property
{
protected:
  string license;

public:
  Commercial();
  Commercial(string theOwner, string theAddress, string theSuburb,
              int thepostCode, string theLicense);

   ~Commercial() ;

   Commercial(const Commercial& orig);

  void input() ;   // Data input for a Shop object
  void print() ;  // Data output for a Shop object

  string getLicense() const {return license;};   //Note the use of const

  void setLicense(string theLicense) {license = theLicense;};

};

property_a.cpp file

#include "property_a.h"

Property::Property(){
   owner = "NULL";
   address = "NULL";
   suburb = "NULL";
   postcode = 0;
}

Property::Property(string theOwner, string theAddress,
                   string theSuburb, int thepostCode):
                     owner(theOwner), address(theAddress),
                     suburb(theSuburb), postcode(thepostCode){}

Property::~Property() {}

Property::Property(const Property& orig) :
                     owner(orig.getOwner()), address(orig.getAddress()),
                     suburb(orig.getSuburb()), postcode(getPostcode()) {}

property_a.h file

#ifndef __PROPERTY_A_H__
#define __PROPERTY_A_H__


/*TODO  REQUIRED HEADER FILES AND NAMESPACES*/
#include <string>
#include "utility1.h"

class Property
{
protected:
  string owner;
  string address;
  string suburb;
  int postcode;

public:
  Property();
  Property(string theOwner, string theAddress, string theSuburb, int thepostCode);
  virtual ~Property();
  Property(const Property& orig);
  virtual void input() ;   // Data input for a Property object
  virtual void print() ;  // Data output for a Property object

  string getOwner() const {return owner;};   //Note the use of const
  string getAddress() const {return address;};
  string getSuburb() const {return suburb;};
  int getPostcode() const {return postcode;};

  void setOwner(string newOwner) {owner = newOwner;};
  void setAddress(string newAddress) {address = newAddress;};
  void setSuburb( string  newSuburb) {suburb = newSuburb;};
  void setPostcode(int  newPostcode) {postcode = newPostcode;};
};
#endif

I hope this is enough details

Answer 1

properties[2] = new Commercial(dynamic_cast(properties[0])); // <-- the copy constructor I can not get to work.

This is casting properties[0] to Commercial*. But this isn't the signature of your copy constructor. Therefore, you need new Commercial(*dynamic_cast<Commercial*>(properties[0]));.

In this example you could use static_cast<Commercial&>(*properties[0]) since you know properties[0] is a Commercial type.

However, in general if you're using dynamic_cast it probably means you're not sure what the derived type is and you would need to check for NULL (i.e., the cast failed) before dereferencing.

Alternative

You could consider a polymorphic API to take care of this for you.

class Base
{
public:
    virtual ~Base() = default;
    Base* clone() const = 0;
};

class D1 : public Base
{
public:
    virtual ~D1() override = default;
    D1* clone() const { return new D1(*this); }
};

class D2 : public Base
{
public:
    virtual ~D2() override = default;
    D2* clone() const { return new D2(*this); }
};

int main()
{
    std::unique_ptr<Base> b1(new D2());
    std::unique_ptr<Base> b2(b1->clone());

    return 0;
}

Answer 2

It would be nice to see the errors but it looks like you aren't calling the copy constructor at all:

new Commercial(dynamic_cast<Commercial*>(properties[0]));

is like calling

Commercial(Commercial * other);

so you need

new Commercial(*dynamic_cast<Commercial*>(properties[0]));