Как обратится к обьекту класса, являющегося наследником абстрактного класса

class aGasStation
{
    friend class bCar;
    friend class cTruck;
protected :
    double A92;
    double A95;
    double A98;
    int cistern92;
    int cistern95;
    int cistern98;
public:
    aGasStation ();
    ~aGasStation ();
    virtual void print () = 0;
};
 
class bCar : public aGasStation
{
    eFuel fuelcar;
public:
    bCar ();
    ~bCar ();
    void print ();
};
 
class cTruck  : public aGasStation
{
    eFuel fueltruck;
public:
    cTruck ();
    ~cTruck ();
    void print ();
};
 
class dChainOfGasStation
{
    aGasStation *base;
    double money;
    static int size;
public:
    dChainOfGasStation ();
    ~dChainOfGasStation ();
    friend void buildCar (dChainOfGasStation *tmp);
    friend void buildTruck (dChainOfGasStation *tmp);
};

void main ()
{
    dChainOfGasStation base;
    buildCar (&base);
    buildCar (&base);
    buildTruck (&base);
    buildCar (&base);   
}

base.base[0]->print();

class D : public C
{
};
int main()
{
    D d;
    return 0;
}

class Graph;
class Vertex;
class Edge;
 
typedef std::vector<Vertex*> VContainer;
typedef std::vector<Edge*>   EContainer;
 
class DependencyManager
{
     friend class Graph;
     friend class Vertex;
     friend class Edge;
 
   private:
     static Vertex* createVertex(Graph* graph);
     static void destroyVertex(Vertex* vertex);
 
     static Edge* createEdge(Graph* graph,Vertex* from,Vertex* to);
     static void  destroyEdge(Edge* edge);
 
     static void clear(Graph* graph);
};
//----------------- Graph ------------------------------------
class Graph: private NonCopyable
{
     friend class DependencyManager;
   public:
     Graph();
     virtual ~Graph();
 
     const VContainer& vertices() const { return vertices_; }
     const EContainer& edges()    const { return edges_; }
 
     Vertex* addVertex();
     Edge*   addEdge(Vertex* from,Vertex* to);
     void clear();
 
   private:
     VContainer vertices_;
     EContainer edges_;
     bool clearMode_;
};
 
Graph::Graph():NonCopyable(),clearMode_(false)
{
 
}
 
Graph::~Graph()
{
   clear();
}
 
Vertex *Graph::addVertex()
{
   return DependencyManager::createVertex(this);
}
 
Edge *Graph::addEdge(Vertex *from, Vertex *to)
{
   return DependencyManager::createEdge(this,from,to);
}
 
void Graph::clear()
{
   DependencyManager::clear(this);
}
//------------------- Vertex ------------------------------------
class Vertex: private NonCopyable
{
    friend class DependencyManager;
  public:
    virtual ~Vertex();
 
    const EContainer& inEdges() const{ return inEdges_;  }
    const EContainer& outEdges()const{ return outEdges_; }
 
    Graph* graph()const{ return graph_; }
 
  private:
    Vertex(Graph* graph):graph_(graph){}
 
    Graph* graph_;
    EContainer inEdges_;
    EContainer outEdges_;
};
 
Vertex::~Vertex()
{
  DependencyManager::destroyVertex(this);
  std::cout<<"~Vertex()"<<std::endl;
}
//------------------- Edge ------------------------------------
class Edge: private NonCopyable
{
     friend class DependencyManager;
   public:
     virtual ~Edge();
     Vertex* from()const { return from_; }
     Vertex* to()  const { return to_; }
 
     Graph* graph()const{ return graph_; }
 
   private:
     Edge(Graph* graph,Vertex* from,Vertex* to);
 
     Graph* graph_;
     Vertex* from_;
     Vertex* to_;
};
 
Edge::Edge(Graph *graph, Vertex *from, Vertex *to)
  :NonCopyable(),graph_(graph),from_(from),to_(to)
{
 
}
 
Edge::~Edge()
{
    DependencyManager::destroyEdge(this);
    std::cout<<"~Edge()"<<std::endl;
}
//------------------- DependencyManager ------------------------
Vertex *DependencyManager::createVertex(Graph *graph)
{
  assert(graph);
  Vertex* vertex= new Vertex(graph);
  graph->vertices_.push_back(vertex);
  return vertex;
}
 
Edge *DependencyManager::createEdge(Graph *graph, Vertex *from, Vertex *to)
{
   assert(graph && from!=to && graph==from->graph_ && graph==to->graph_);
   Edge* edge= new Edge(graph,from,to);
   graph->edges_.push_back(edge);
   from->outEdges_.push_back(edge);
   to->inEdges_.push_back(edge);
   return edge;
}
 
void DependencyManager::destroyVertex(Vertex *vertex)
{
  assert(vertex);
  if(!vertex->graph_->clearMode_)
  {
    findAndErase(vertex->graph_->vertices_,vertex);
    deleteAll(vertex->inEdges_);
    deleteAll(vertex->outEdges_);
    vertex->inEdges_.clear();
    vertex->outEdges_.clear();
  }
}
 
void DependencyManager::destroyEdge(Edge *edge)
{
  assert(edge);
  if(!edge->graph_->clearMode_)
  {
    findAndErase(edge->graph_->edges_,edge);
    findAndErase(edge->from_->outEdges_,edge);
    findAndErase(edge->to_->inEdges_,edge);
  }
}
 
void DependencyManager::clear(Graph *graph)
{
  assert(graph);
  graph->clearMode_= true;
 
  deleteAll(graph->vertices_);
  deleteAll(graph->edges_);
 
  graph->vertices_.clear();
  graph->edges_.clear();
 
  graph->clearMode_= false;
}
 
 
int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);
 
    Graph g;
    Vertex* v1= g.addVertex();
    Vertex* v2= g.addVertex();
 
    Edge* e= g.addEdge(v1,v2);
 
    delete v1;
 
    return a.exec();
}

#include <iostream>
#include <memory>
 
// --- найдите 10 принципиальных отличий
 
class Base {};
 
 
class C1 : public Base
{
public:
    static std::unique_ptr<C1> create()
    {
        std::unique_ptr<C1> x(new C1);
        x->v = 10;
        return x;
    }
    
private:
    C1() {}
    int v;
};
 
class C2 : public Base
{
public:
    friend std::unique_ptr<C2> create();
   
private:
    C2() {}
    
    int v;
};
std::unique_ptr<C2> create()
{
    std::unique_ptr<C2> x(new C2);
    x->v = 10;
    return x;
}
 
 
 
int main()
{
    std::cout << "Hello, world!\n";
    
    // --- смотреть на дизайн использования:
    auto obj1 = C1::create();
    auto obj2 = create();
}

#include <iostream>
#include <memory>
 
// --- найдите 10 принципиальных отличий
 
class Base {};
 
 
class C1 : public Base
{
public:
    static std::unique_ptr<C1> create()
    {
        std::unique_ptr<C1> x(new C1);
        x->v = 10;
        return x;
    }
    
private:
    C1() {}
    int v;
};
 
class C2 : public Base
{
public:
    friend std::unique_ptr<C2> create()
    {
        std::unique_ptr<C2> x(new C2);
        x->v = 10;
        return x;
    }
 
   
private:
    C2() {}
    
    int v;
};
std::unique_ptr<C2> create();
 
 
int main()
{
    std::cout << "Hello, world!\n";
    
    // --- смотреть на дизайн использования:
    
    auto obj1 = C1::create();
    
    auto obj2 = create();
    
}

    Graph g;
    Vertex* v1= g.addVertex();
    Vertex* v2= g.addVertex();
 
    Edge* e= g.addEdge(v1,v2); //<--- закатали указатель
 
    delete v1; //ой, а чего это мы тут прибили ненароком?

Edge *DependencyManager::createEdge(Graph *graph, Vertex *from, Vertex *to)
{
   assert(graph && from!=to && graph==from->graph_ && graph==to->graph_);
   Edge* edge= new Edge(graph,from,to);
   graph->edges_.push_back(edge);
   from->outEdges_.push_back(edge);   //<--- вах! вах!!! 
   to->inEdges_.push_back(edge);
   return edge;
}

    
    Graph g;
    Vertex& v1= g.addVertex();
    Vertex& v2= g.addVertex();
    g.addEdge(v1,v2);

сontainer::iterator it = cont.begin();

Vertex(Graph* graph):graph_(graph){}

Edge(Graph* graph,Vertex* from,Vertex* to);