Перегрузка << оператор, входящий в полиморфный объект

Question

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

Я хотел был бы перегрузить <<operator, чтобы я мог «перетекать» в другой. Я хотел бы A << B, чтобы быть уменьшен до A->setNext(B), где эта функция хранит B в массиве - так что я могу сделать это пять раз и иметь все 5 в массиве.

Я хотел бы написать код для этого в 2 базовых классах и иметь функции, унаследованные там дочерними классами. Это возможно?

Answer 1

В базовом классе, вам нужно Somthing как:

class Base 
{ 
    virtual void streamInto(Base const& other) = 0; 
public: 
    Base& operator<<(Base const& other) 
    { 
     streamInto(other); 
     return *this; 
    } 
}; 

Конечно, это по-прежнему оставляет смысловое открытым: что каждый из производные классы делать с Base const& они получают? Если поведение в A также зависит от типа other, вы должны придется выполнить одну из классических двухсторонней отправки .

И делает << действительно применимо здесь? Если нет форматирования в внешнего формата, это, вероятно, злоупотребление перегрузкой оператора. Смещение, на чем-то вроде BigInteger класса, также было бы приемлемым, но вот и об этом.

Answer 2

Это может быть что-то похожее на то, что вы ищете.

// In B.hpp: 
#include <memory> 

class TypeB 
    : public std::enable_shared_from_this<TypeB> 
{ 
    //... 
}; 

// In A.hpp: 
#include <memory> 
#include <vector> 
#include "B.hpp" 

class TypeA 
{ 
public: 
    TypeA& operator<<(TypeB& source); 
    virtual void reset_B_list(); // (maybe) 
    //... 
private: 
    typedef std::vector<std::shared_ptr<TypeB>> B_list_type; 
protected: 
    typedef B_list_type::const_iterator B_iter_type; 
    B_iter_type B_list_begin() const; 
    B_iter_type B_list_end() const; 
    virtual void added_B(TypeB& new_source); 
private: 
    B_list_type m_B_list; 
    //... 
}; 

inline TypeA& TypeA::operator<<(TypeB& source) { 
    m_B_list.push_back(source.shared_from_this()); 
    added_B(new_source); 
    return *this; 
} 

Не забудьте заменить любые new B(args) выражения с std::make_shared<B>(args).

Если вы не можете использовать std::shared_ptr, почти точно такая же вещь в Boost.

Я согласен с Джеймсом в том, что это может быть злоупотребление перегрузкой, в зависимости от того, что все это делает. Рассмотрим только с помощью обычного имени функции, как setNext, streamInto, и т.д. Если она возвращает TypeA&, вы можете «цепь» вызывает к нему, как A.streamInto(B1).streamInto(B2); вместо A << B1 << B2;