Наследование: Трансформатор(Т), Щиток(Щ), Линии с нагрузкой(Л)

class Line:public Object
{
public:
    enum { Id = 0 };
 
    Line(Object* owner) : owner_(owner){  }
     ~Line()
    { 
        for (size_t i = 0; i<subObjects_.size(); ++i)
            delete subObjects_[i];
    };
 
    void addSubObjects(Object*  sub){ subObjects_.push_back(sub); }
    int typeId(){ return Id; }
    Object* owner(){ return owner_; };
    virtual double power() { return power_; } 
 
private:
    double power_;
    Object* owner_;
    std::vector<Object*> subObjects_;
};

class Line:public Object
{
public:
    enum { Id = 0 };
 
    Line(Object* owner) : Object(owner){  }
 
 /*Нафига? все что ниже уже определено в базовом классе*/
//    void addSubObjects(Object*  sub){ subObjects_.push_back(sub); }
//   int typeId(){ return Id; }
//   Object* owner(){ return owner_; };
//   virtual double power() { return power_; } 
 
private:
 
//    double power_;
//    Object* owner_;
//    std::vector<Object*> subObjects_;
};

/////////////////////////////////////////////////////////////////////////////////////////
//программу связанную с расчетом эл.сети, существуют объекты Трансформатор(Т), Щиток(Щ), 
//Линии с нагрузкой(Л). Условно, есть 1 Т, к нему подключены 2 Щ , к каждому их которых 
//подключено по 3 Л. Вопрос: как лучше реализовать эту привязку Щ к Т , Л к Щ? это делается 
//через наследование(Л наследуется от Щ, Щ наследуется от Т)
//
//в расчете каждый элемент имеет такие параметры как нагрузка(мощность, которую потребляет 
//сам элемент+мощность всех его "детей") 
//
//связь между объектами разных классов например создать линию Л1 на ней 2 светильника 
//по 100 Вт, собственные потери линии например 20 Вт, т.е. через нее протекает 220 Вт, 
//на основании этого значения выбирается ее сечение , но если от нее будет идти еще одна 
//линия Л2 с 3мя светильниками по 50 Вт и собственными потерями 10 Вт, то через Л1 уже 
//будет протекать 220+50*3+10=380 Вт, и уже другое сечение. Т.е. грубо говоря элементы, 
//которые ниже по иерархии, передают верхнему свой параметр "мощность". 
/////////////////////////////////////////////////////////////////////////////////////////
#include <iostream>
#include <map>
#include <memory>
#include <numeric>
/////////////////////////////////////////////////////////////////////////////////////////
class   T_electric_object
{
    //-----------------------------------------------------------------------------------
    typedef std::shared_ptr < T_electric_object             >   T_electric_object_ptr;
    typedef std::multimap   < int,  T_electric_object_ptr   >   T_electric_object_ptr_of_id;
    //-----------------------------------------------------------------------------------
    static  int                     id_counter_;
    int                             ID_;
    double                          power_;
    T_electric_object_ptr_of_id     electric_object_ptr_of_id_;
    //-----------------------------------------------------------------------------------
public:
    //-----------------------------------------------------------------------------------
    T_electric_object( double  power )
        :
        ID_     ( id_counter_++ ),
        power_  ( power         )
    {}
    //-----------------------------------------------------------------------------------
    int     get_id()                                                                const
    {
        return  ID_;
    }
    //-----------------------------------------------------------------------------------
    virtual     double  get_power()                                                 const
    {
        return  power_;
    }
    //-----------------------------------------------------------------------------------
    void    set_power( double   power )
    {
        power_  =   power;
    }
    //-----------------------------------------------------------------------------------
    void    insert( T_electric_object   const   &   obj )
    {
        electric_object_ptr_of_id_.insert
            (
                std::make_pair
                    (
                        obj.get_id(),
 
                        T_electric_object_ptr
                            (
                                new   T_electric_object( obj )
                            )
                    )
            );
    }
    //-----------------------------------------------------------------------------------
    template< typename  T >
    T_electric_object   &   operator<<( T  t )
    {
        insert(t);
        return  *this;
    }
    //-----------------------------------------------------------------------------------
    void    erase( T_electric_object   const   &   obj )
    {
        auto    it  =   electric_object_ptr_of_id_.find
                            (
                                obj.get_id()
                            );
 
        if  (
                it  !=  electric_object_ptr_of_id_.end()
            )
        {
            electric_object_ptr_of_id_.erase( it );
        }
    }
    //-----------------------------------------------------------------------------------
    template< typename  T >
    T_electric_object   &   operator>>( T  t )
    {
        erase(t);
        return  *this;
    }
    //-----------------------------------------------------------------------------------
    virtual     double  get_total_power()                                           const
    {
        return  std::accumulate
                    (
                        electric_object_ptr_of_id_.begin    (),
                        electric_object_ptr_of_id_.end      (),
                        get_power                           (),
 
                        []  (
                                double                                      sum,
                                T_electric_object_ptr_of_id::value_type     id_and_electric_object_ptr
                            )
                        {
                            return      sum
                                    +   id_and_electric_object_ptr.second->get_total_power();
                        }
                    );
    }
    //-----------------------------------------------------------------------------------
};
/////////////////////////////////////////////////////////////////////////////////////////
int     T_electric_object::id_counter_  =   0;
/////////////////////////////////////////////////////////////////////////////////////////
class   T_transformer   :   public  T_electric_object
{
    //-----------------------------------------------------------------------------------
public:
    //-----------------------------------------------------------------------------------
    T_transformer( double  power )
        :
        T_electric_object( power )
    {}
    //-----------------------------------------------------------------------------------
};
/////////////////////////////////////////////////////////////////////////////////////////
class   T_power_line    :   public  T_electric_object
{
    //-----------------------------------------------------------------------------------
public:
    //-----------------------------------------------------------------------------------
    T_power_line( double  power )
        :
        T_electric_object( power )
    {}
    //-----------------------------------------------------------------------------------
};
/////////////////////////////////////////////////////////////////////////////////////////
class   T_panelboard    :   public  T_electric_object
{
    //-----------------------------------------------------------------------------------
public:
    //-----------------------------------------------------------------------------------
    T_panelboard( double  power )
        :
        T_electric_object( power )
    {}
    //-----------------------------------------------------------------------------------
};
/////////////////////////////////////////////////////////////////////////////////////////
class   T_luminaire     :   public  T_electric_object
{
    //-----------------------------------------------------------------------------------
public:
    //-----------------------------------------------------------------------------------
    T_luminaire( double  power )
        :
        T_electric_object( power )
    {}
    //-----------------------------------------------------------------------------------
};
/////////////////////////////////////////////////////////////////////////////////////////
int     main()
{
    T_luminaire     lum_100     ( 100 );
    T_luminaire     lum_200     ( 200 );
 
    T_power_line    line_1      ( 10 );
 
    line_1  <<  lum_100
            <<  lum_200;
 
    T_power_line    line_2      ( 20 );
    line_2  <<  lum_100;
 
    T_power_line    line_3      ( 30 );
    line_3  <<  lum_200;
 
    T_power_line    line_4      ( 40 );
 
    line_4  <<  lum_200
            <<  lum_200;
 
    T_power_line    line_5  =   line_1;
    line_5.set_power( 50 );
 
    std::cout   <<  line_5.get_total_power()
                <<  std::endl;
 
    T_panelboard    panelboard_1( 10 );
 
    panelboard_1    <<  line_1
                    <<  line_2;
 
    std::cout   <<  panelboard_1.get_total_power()
                <<  std::endl;
 
    T_panelboard    panelboard_2( 20 );
 
    panelboard_2    <<  line_3
                    <<  line_4
                    <<  line_5;
 
    std::cout   <<  panelboard_2.get_total_power()
                <<  std::endl;
 
    T_power_line    line_11( 100 );
    line_11     <<  panelboard_1;
 
    std::cout   <<  line_11.get_total_power()
                <<  std::endl;
 
    T_power_line    line_22( 200 );
    line_22     <<  panelboard_2;
 
    T_transformer   transformer( 1000 );
 
    transformer     <<  line_11
                    <<  line_22;
 
    std::cout   <<  transformer.get_total_power()
                <<  std::endl;
 
    transformer     >>  line_11;
 
    std::cout   <<  transformer.get_total_power()
                <<  std::endl;
 
    system("pause");
}