Свободные интерфейсы и наследование в C ++ - PullRequest
Новая
       29

Свободные интерфейсы и наследование в C ++

7 голосов
/ 25 июня 2009

Я хотел бы создать базовый (абстрактный) класс (назовем его type::base) с некоторой общей функциональностью и свободным интерфейсом, проблема, с которой я сталкиваюсь, заключается в типе возврата всех этих методов 

  class base {
    public:
       base();
       virtual ~base();

       base& with_foo();
       base& with_bar();
    protected:
       // whatever...
  };

Теперь я могу создавать подтипы, например ::1005 * 

  class my_type : public base {
    public:
      myType();        
      // more methods...
  };

Проблема возникает при использовании таких подтипов, как этот: 

 my_type build_my_type()
 {
    return my_type().with_foo().with_bar();
 }

Это не скомпилируется, потому что мы возвращаем base вместо my_type.

Я знаю, что мог бы просто: 

 my_type build_my_type()
 {
    my_type ret;
    ret.with_foo().with_bar();

    return ret;
 }

Но я думал о том, как я могу это реализовать, и я не нашел никаких действительных идей, каких-то предложений?

Ответы [ 5 ]

5 голосов
/ 25 июня 2009

Вы должны возвращать ссылки / указатели, и вам не нужно хранить информацию о типе. 

class base {
  public:
     base();
     virtual ~base();

     base &with_foo();
     base &with_bar();
  protected:
     // whatever...
};

class my_type : public base {
  public:
    my_type();        
    // more methods...
};

base *build_my_type()
{
   return &new my_type()->with_foo().with_bar();
}

У вас уже есть виртуальный деструктор. Предположительно у вас есть другие виртуальные функции. Доступ ко всему через базовый тип и объявленные там виртуальные функции.

4 голосов
/ 25 июня 2009

Эту проблему «потери типа» можно решить с помощью шаблонов, но она довольно сложная.

Например. 

class Pizza
{
  string topping;
public:
  virtual double price() const;
};

template <class T, class Base>
class FluentPizza : public Base
{
  T* withAnchovies() { ... some implementation ... };
};

class RectPizza : public FluentPizza<RectPizza, Pizza>
{
  double price() const { return length*width; :) }
};

class SquarePizza : public FluentPizza<SquarePizza, RectPizza>
{
   ... something else ...
};

Вы можете написать 

SquarePizza* p=(new SquarePizza)->withAnchovies();

Шаблон таков, что вместо 

class T : public B

вы пишете 

class T : public Fluent<T, B>

Другой подход может заключаться не в использовании свободного интерфейса на объектах, а в указателях: 

class Pizza { ... };
class RectPizza { ... };
class SquarePizza { ... whatever you might imagine ... };

template <class T>
class FluentPizzaPtr
{
  T* pizza;
public:
  FluentPizzaPtr withAnchovies() {
    pizza->addAnchovies(); // a nonfluent method
    return *this;
  }
};

Используйте вот так: 

FluentPizzaPtr<SquarePizza> squarePizzaFactory() { ... }

FluentPizzaPtr<SquarePizza> myPizza=squarePizzaFactory().withAnchovies();
0 голосов
/ 25 июня 2009

В C ++ вы должны получать указатели или ссылки, а не значения. Кроме того, вы можете объяснить, что вы подразумеваете под «текучими интерфейсами».

0 голосов
/ 25 июня 2009

Одно решение будет работать так: 

return *static_cast<my_type*>(&my_type().with_foo().with_bar());

Использование static_cast в основном говорит компилятору «Я знаю, что я здесь делаю».

0 голосов
/ 25 июня 2009

Способ, которым я бы сделал это в C #, и я верю, что он будет работать и в C ++, - это обеспечить реализацию по умолчанию для with_foo() и with_bar() ... Простите мой #, но: 

class base {
  virtual base with_foo()
  { throw new NotImplementedException(); }
  virtual base with_bar();
  { throw new NotImplementedException(); }
}
...