Ищете лучший способ, чем виртуальное наследование в C++

Я полагаю, что шаблон фасад должен помочь.

Оберните сторонний интерфейс в собственный интерфейс, и код вашего приложения будет работать с интерфейсом оболочки, а не со сторонним интерфейсом. Таким образом, вы также хорошо изолировали изменения в неконтролируемом стороннем интерфейсе.

У нас была очень похожая проблема в проекте, и мы решили ее, просто НЕ унаследовав ImprovedShape от Shape. Если вам нужна функциональность формы в ImprovedShape, вы можете использовать dynamic_cast, зная, что ваше приведение всегда будет работать. А в остальном как в вашем примере.

Почему этот класс должен происходить от формы?

class ImprovedShape : public virtual Shape
{
    virtual double GetArea() const = 0;
};

Почему бы просто не иметь

class ThingWithArea 
{
    virtual double GetArea() const = 0;
};

ImprovedSquare - это форма и ThingWithArea

Возможно, вам следует прочитать правильное наследование и сделать вывод, что ImprovedShape не нужно наследовать от Shape, но вместо этого может использовать Shape для своих функций рисования, аналогично обсуждению в пункте 21.12 этого FAQ о том, как SortedList не должен наследовать от List, даже если он хочет обеспечить ту же функциональность, он может просто использовать a List.

Аналогичным образом ImprovedShape может использовать Shape, чтобы делать то, что она делает.

Возможно, использование шаблона декоратора? [http://en.wikipedia.org/wiki/Decorator_pattern[1]

Можно ли сделать совершенно другой подход - использовать шаблоны и методы метапрограммирования? Если вы не обязаны не использовать шаблоны, это может стать элегантным решением. Меняются только ImprovedShape и ImprovedSquare:

template <typename ShapePolicy>
class ImprovedShape : public ShapePolicy
{
public:
    virtual double GetArea();
    ImprovedShape(void);
    virtual ~ImprovedShape(void);

protected:
    ShapePolicy shape;
    //...
};

и ImprovedSquare становится:

class ImprovedSquare : public ImprovedShape<Square>
{
public:
    ImprovedSquare(void);
    ~ImprovedSquare(void);

    // ...

};

Вы избежите наследования ромба, получив как наследование от исходной формы Shape (через класс политики), так и дополнительные функции, которые вам нужны.

Подход Дэйва Хиллера правильный. Разделите GetArea() на отдельный интерфейс:

class ThingWithArea
{
public:
    virtual double GetArea() const = 0;
};

Если бы дизайнеры Shape поступили правильно и сделали интерфейс в чистом виде, а общедоступные интерфейсы конкретных классов были достаточно мощными, вы могли иметь экземпляры конкретных классов в качестве членов. Вот так получается SquareWithArea (ImprovedSquare - плохое название), будучи Shape и ThingWithArea:

class SquareWithArea : public Shape, public ThingWithArea
{
public:
    double GetPerimeter() const { return square.GetPerimeter(); }
    double GetArea() const { /* do stuff with square */ }

private:
    Square square;
};

К сожалению, разработчики Shape внедрили некоторую реализацию в Shape, и вы будет иметь две его копии на каждый SquareWithArea, как в алмаз, который вы изначально предложили.

Это в значительной степени подталкивает вас к наиболее тесно связанным и, следовательно, наименее связанным желательно, раствор:

class SquareWithArea : public Square, public ThingWithArea
{
};

В наши дни считается дурным тоном выводить нас из конкретных классов в C++. Трудно найти действительно хорошее объяснение, почему вам не следует этого делать. Обычно люди процитируйте статью 33 Мейерса «Более эффективный C++», в которой указывается на невозможность написать достойный operator=() среди прочего. Возможно, тогда вам следует никогда не делайте этого для классов с семантикой значений. Еще одна ловушка - это то, где конкретный класс не имеет виртуального деструктора (поэтому вам следует никогда не выводятся публично из контейнеров STL). Ни то, ни другое здесь не применимо. Постер кто снисходительно отправил вас на страницу часто задаваемых вопросов по C++, чтобы узнать о наследовании, неправильно - добавление GetArea() не нарушает заменяемость Лисков. О единственный риск, который я вижу, связан с переопределением виртуальных функций в конкретные классы, когда разработчик позже меняет имя и молча прерывает ваш код.

Подводя итог, я думаю, что вы можете получить от Square с чистой совестью. (В качестве утешения вам не придется писать все функции переадресации для интерфейс формы).

Теперь перейдем к проблеме функций, которым нужны оба интерфейса. Мне не нравится ненужные dynamic_cast. Вместо этого заставьте функцию использовать ссылки на оба интерфейса и передают ссылки на один и тот же объект для обоих на сайте вызова:

void PrintPerimeterAndArea(const Shape& s, const ThingWithArea& a)
{
    cout << s.GetPerimeter() << endl;
    cout << a.GetArea() << endl;
}

// ...

SquareWithArea swa;
PrintPerimeterAndArea(swa, swa);

Все, что PrintPerimeterAndArea() необходимо для выполнения своей работы, - это источник периметра и источник площади. Его не беспокоит, что они будут реализованы. как функции-члены в одном экземпляре объекта. Предположительно, этот район мог поставляться каким-либо механизмом численного интегрирования между ним и Shape.

Это подводит нас к единственному случаю, когда я бы подумал о передаче одной ссылки и получить другой с помощью dynamic_cast - где важно, чтобы два ссылки относятся к одному и тому же экземпляру объекта. Вот очень надуманный пример:

void hardcopy(const Shape& s, const ThingWithArea& a)
{
    Printer p;
    if (p.HasEnoughInk(a.GetArea()))
    {
        s.print(p);
    }
}

Даже в этом случае я, вероятно, предпочел бы прислать две ссылки, а не dynamic_cast. Я бы полагался на разумный общий дизайн системы, чтобы исключить возможность передачи битов двух разных экземпляров в такие функции.

Еще один подход к метапрограммированию / миксину, на этот раз немного под влиянием трейтов. Предполагается, что вычисляемая площадь - это то, что вы хотите добавить на основе открытых свойств; вы могли бы сделать что-то, что сохранялось бы с инкапсуляцией, это цель, а не модуляризация. Но тогда вам нужно написать GetArea для каждого подтипа, а не использовать полиморфный, где это возможно. Стоит ли это того, зависит от того, насколько вы привержены инкапсуляции, и есть ли в вашей библиотеке базовые классы, которые вы можете использовать, например, Прямоугольная форма ниже.

#import <iostream>

using namespace std;

// base types
class Shape {
    public:
        Shape () {}
        virtual ~Shape () { }
        virtual void DoShapyStuff () const = 0;
};

class RectangularShape : public Shape {
    public:
        RectangularShape () { }

        virtual double GetHeight () const = 0 ;
        virtual double GetWidth  () const = 0 ;
};

class Square : public RectangularShape {
    public:
        Square () { }

        virtual void DoShapyStuff () const
        {
            cout << "I\'m a square." << endl;
        }

        virtual double GetHeight () const { return 10.0; }
        virtual double GetWidth  () const { return 10.0; }
};

class Rect : public RectangularShape {
    public:
        Rect () { }

        virtual void DoShapyStuff () const
        {
            cout << "I\'m a rectangle." << endl;
        }

        virtual double GetHeight () const { return 9.0; }
        virtual double GetWidth  () const { return 16.0; }
};

// extension has a cast to Shape rather than extending Shape
class HasArea {
    public:
        virtual double GetArea () const = 0;
        virtual Shape& AsShape () = 0;
        virtual const Shape& AsShape () const = 0;

        operator Shape& ()
        {
            return AsShape();
        }

        operator const Shape& () const
        {
            return AsShape();
        }
};

template<class S> struct AreaOf { };

// you have to have the declaration before the ShapeWithArea 
// template if you want to use polymorphic behaviour, which 
// is a bit clunky
static double GetArea (const RectangularShape& shape)
{
    return shape.GetWidth() * shape.GetHeight();
}

template <class S>
class ShapeWithArea : public S, public HasArea {
    public:
        virtual double GetArea () const
        {
            return ::GetArea(*this);
        }
        virtual Shape& AsShape ()             { return *this; }
        virtual const Shape& AsShape () const { return *this; }
};

// don't have to write two implementations of GetArea
// as we use the GetArea for the super type
typedef ShapeWithArea<Square> ImprovedSquare;
typedef ShapeWithArea<Rect> ImprovedRect;

void Demo (const HasArea& hasArea)
{
    const Shape& shape(hasArea);
    shape.DoShapyStuff();
    cout << "Area = " << hasArea.GetArea() << endl;
}

int main ()
{
    ImprovedSquare square;
    ImprovedRect   rect;

    Demo(square);
    Demo(rect);

    return 0;
}

Насколько я понял вопрос, решение вашей проблемы существует. Используйте addapter-pattern. Шаблон адаптера используется для добавить функциональность к определенному классу или обмениваться определенным поведением (т.е. методов). Учитывая нарисованный вами сценарий:

class ShapeWithArea : public Shape
{
 protected:
  Shape* shape_;

 public:
  virtual ~ShapeWithArea();

  virtual position GetPosition() const { return shape_->GetPosition(); }
  virtual void SetPosition(position)   { shape_->SetPosition(); }
  virtual double GetPerimeter() const  { return shape_->GetPerimeter(); }

  ShapeWithArea (Shape* shape) : shape_(shape) {}

  virtual double getArea (void) const = 0;
};

Шаблон-адаптер предназначен для адаптации поведения или функциональности класса. Вы можете использовать это для

• изменить поведение класса, не перенаправляя, а повторно реализуя методы.
• добавить поведение к классу, добавив методы.

Как это меняет поведение? Когда вы предоставляете объект типа base методу, вы также можете предоставить адаптированный класс. Объект будет вести себя так, как вы его проинструктировали, актор на объекте будет заботиться только об интерфейсе базового класса. Вы можете применить этот адаптер к любому производному от Shape.

GetArea () не обязательно должен быть участником. Это может быть шаблонная функция, чтобы вы могли вызывать ее для любой формы.

Что-то типа:

template <class ShapeType, class AreaFunctor> 
int GetArea(const ShapeType& shape, AreaFunctor func);

Функции STL мин, Максимум можно рассматривать как аналогию для вашего случая. Вы можете найти минимальное и максимальное значение для массива / вектора объектов с учетом функции компаратора. Точно так же вы можете получить площадь любой заданной формы с помощью функции вычисления площади.