2

I have an abstract class say Figure and some derived classes: Circle, Square, ...

The class figure implements:

private:
  virtual double varea()=0;
  double multiplier;
public:
  virtual Figure * clone()=0;
  double area() { return varea()*multiplier; }

The figures, Square for instance, behave like this:

private:
  double L;
public:
  virtual Figure * clone() {return new Square(*this);}
  virtual double varea() {return L*L;}

I'm having difficulties to assign the variable multiplier when calling the method clone. What is the best way to achieve this? Of course this is just a stupid example with a number of workarounds, but in reality, with multiple levels of derivation, they are not so obvious, so please stick to this pattern.

Should I go for a virtual interface also for the method clone? In this way I can assign the multiplier directly in the Figure class without any need to let each figure know its multiplier.

DarioP
  • 5,377
  • 1
  • 33
  • 52
  • multiplier is private, so you'll either need a protected setter, or a constructor that takes multiplier as a parameter. Sub class constructor can then pass the multiplier value to the parent constructor. – UltraInstinct Dec 18 '13 at 09:30
  • @Thrustmaster I was hoping to be able to avoid editing all the existing derived figures and keep light constructors for the ones I still have to write. There is really no other reason for figures to see their multiplier. – DarioP Dec 18 '13 at 09:34

3 Answers3

1

Unless you declare a copy constructor for your class Figure the language gives you one au gratis, and it's public. You do not want this freebie public copy constructor. It will lead to slicing. Make your copy constructor for class Figure protected. Your copy constructor for the non-abstract derived classes should invoke this protected copy constructor. With this, the clone member function is as simple as new DerivedClass (*this):

class Figure {
private:
   virtual double varea()=0;
   double multiplier;
protected:
   Figure () : multiplier(1.0) {}
   Figure (const Figure& src) : multiplier(src.multiplier) {}
public:
   virtual Figure* clone()=0;
   double area() { return varea()*multiplier; }
};

class Square: public Figure {
private:
   virtual double varea() {return L*L;}
   double L;
public:
  Square(const Square & src) : Figure(src), L(src.L) {}
  virtual Figure* clone() {return new Square(*this);}
};

Note well:

  • I made Square::varea() private because that's how it's declared in class Figure. Exposing a parent class's private method as public in a derived class typically is a bit dubious.
  • There's an issue with the assignment operator. I'll leave this up to you.
  • You need some way to set the multiplier.
David Hammen
  • 32,454
  • 9
  • 60
  • 108
1

Inheritance connect awkwardly with copy semantics. However, one solution could be let the copy constructor do the job : 

struct Base
{
public:
    Base()=default;
    virtual ~Base()=default;

    virtual Base* clone()=0;

    Base& operator=(Base const &) = delete;
    Base(Base&&)=delete;
protected:
    Base(Base const&) = default;
};

struct Derivated : Base
{
public:
    Derivated()=default;

    virtual Derivated * clone()
    {
        return new Derivated (*this);
    }
protected:
    Derivated(Derivated const&) = default;
};
Qassim
  • 96
  • 3
  • Is the fact that in the class Derivated the clone method returns a `Derivated *` only a typo? I'm not very familiar with default copy ctors, is `Derivated(Derivated const&)=default;` calling also `Base(Base const&)`? – DarioP Dec 18 '13 at 10:59
0

Add a protected accessors to the figure class:

protected:
  double getMultiplier() { return multiplier; }
  void setMultiplier(double newValue) { multiplier = newValue; }

than you'll have access to the multiplier although you'll not have direct acces to the member..

V-X
  • 2,979
  • 18
  • 28