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

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 Drob
    {
    public:
        int x;
        int y;
 
        float       toFloat() const
        {
            return x*1.0 / y;
        }
    };
 
 
Drob a(10, 0);
cout << a.toFloat() << endl;

public:
    enum Mark{ A92,A95,A98 }; 
// A92= 0 ,A95= 1, A98= 2 - будут использоваться как индексы массива.
 
    const double& benzine(Mark mark)const{  return  A_[mark]; } // геттер
    double& benzine(Mark mark){  return  A_[mark]; } // по сути сеттер
 
private:
    double A_[3];// A92,A95,A98
}
 
//
 
double a95= station.benzine(AbstractGusStation::A95);
station.benzine(A95)+= 5; // Увеличиваем на 5 значение засчет возврата ссылки

inline const int& Get()const{return my_int;}
inline int& Get(){return my_int;}

class CarGasStation : public AbstractGasStation
{ 
   friend class ChainOfGasStation;
   protected:
       CarGasStation(){/**/};
  // твой код
};
 
class TruckGasStation : public AbstractGasStation
{
   friend class ChainOfGasStation;
   protected:
     TruckGasStation(){/**/};
  // твой код
};
 
class ChainOfGasStation
{
  public:
     ChainOfGasStation ();
    ~ChainOfGasStation ()
     {  
       clear();
     };
 
    void clear()
   {
       for(size_t i=0;i<station_.size();++i) 
          delete station_[i]; 
       stations_.clear();
   }
 
    AbstractGasStation*  addCarGasStation()
    { 
        AbstractGasStation*  station= new CarGasStation;
        stations_.push_back(station);   
        return station;    
    }  
 
    AbstractGasStation*  addTruckGasStation()
    { 
        AbstractGasStation*  station= new TruckGasStation;
        stations_.push_back(station);   
        return station;    
    }  
 
 
    AbstractGasStation* station(size_t index)
    {
       return stations_.at(index);
    }
   
    size_t size() const
   {
      return station_.size();
   }
 
  private:
     std::vector<AbstractGasStation*> stations_; // Либо массив что усложнит задачу.
};
// ....
ChainOfGasStation  сhain;
сhain.addCarGasStation();
сhain.addTruckGasStation();
 
// TruckGasStation*  truckStation= new TruckGasStation; // Ошибка.