C++ Operator Overload Subscript Operator

 
#include <iostream>
#include <memory>
#include <cstdlib>                     // For random number generator
#include <ctime>                       // For time function
#include <memory>                                             // For smart pointers
#include <vector>                                             // For vector<T>
#include <memory>
#include <vector>
#include <iostream>
#include <iomanip>
 
class  Pool// w  ww .  j a  v  a 2 s .c  o m
{
private:
  double length {1.0};
  double width {1.0};
  double height {1.0};
 
public:
  // Constructors
  Pool(double lv, double wv, double hv) : length {lv}, width {wv}, height {hv} {}
 
  Pool() {}                                                             // No-arg constructor
 
  Pool(const Pool& pool)                                                  // Copy constructor
    : length {pool.length}, width {pool.width}, height {pool.height} {}
 
  double volume() const                                                // Function to calculate the volume
  {
    return length*width*height;
  }
 
  // Accessors
  double getLength() const { return length; }
  double getWidth() const { return width; }
  double getHeight() const { return height; }
 
  bool operator<(const Pool& aPool) const;                               // Less-than operator
  bool operator<(double aValue) const;                                 // Compare Pool volume < double value
  Pool operator+(const Pool& aPool) const;                                // Function to add two Pool objects
 
  friend std::ostream& operator<<(std::ostream& stream, const Pool& pool);
};
 
// Less-than comparison for Pool objects
inline bool Pool::operator<(const Pool& aPool) const
{
  return volume() < aPool.volume();
}
 
// Compare the volume of a Pool object with a constant
inline bool Pool::operator<(double aValue) const
{
  return volume() < aValue;
}
 
// Function comparing a constant with volume of a Pool object
inline bool operator<(double aValue, const Pool& aPool)
{
  return aValue < aPool.volume();
}
 
// Operator function to add two Pool objects
inline Pool Pool::operator+(const Pool& aPool) const
{
  // New object has larger length and width, and sum of heights
  return Pool {length > aPool.length ? length : aPool.length,
    width > aPool.width ? width : aPool.width,
    height + aPool.height};
}
 
// operator to write Pool objects to a stream
inline std::ostream& operator<<(std::ostream& stream, const Pool& pool)
{
  stream << " Pool(" << std::setw(2) << pool.length << ","
    << std::setw(2) << pool.width << ","
    << std::setw(2) << pool.height << ")";
  return stream;
}
 
template <typename T> using ptr = std::shared_ptr<T>;
 
class  Truckload
{
private:
  class  Package
  {
  public:
    ptr<Pool> pPool;                                 // Pointer to the Pool object
    ptr<Package> pNext;                            // Pointer to the next Package
 
    Package(ptr<Pool> pb) : pPool {pb}, pNext {} {}  // Constructor
  };
 
  ptr<Package> pHead;                              // First in the list
  ptr<Package> pTail;                              // Last in the list
  ptr<Package> pCurrent;                           // Last retrieved from the list
 
public:
  Truckload() {}                                   // No-arg constructor empty truckload
 
  Truckload(ptr<Pool> pPool)                         // Constructor - one Pool
  {
    pHead = pTail = std::make_shared<Package>(pPool);
  }
 
  Truckload(const std::vector< ptr<Pool> >& pools); // Constructor - vector of Pools
 
  ptr<Pool> getFirstPool();                          // Get the first Pool
  ptr<Pool> getNextPool();                           // Get the next Pool
  void  addPool(ptr<Pool> pPool);                     // Add a new Pool
  bool deletePool(ptr<Pool> pPool);                   // Delete a Pool
  ptr<Pool> operator[](int index) const;         // Overloaded subscript operator
 
  friend std::ostream& operator<<(std::ostream& stream, Truckload& load);
};
 
// Subscript operator
inline ptr<Pool> Truckload::operator[](int index) const
{
  ptr<Package> p {pHead};                          // Pointer to first Package
  int count {};                                 // Package count
  do {
    if (index == count++)                          // Up to index yet?
      return p->pPool;                              // If so return the pointer to Pool
  } while (p = p->pNext);
  return nullptr;
}
 
// >> operator for output to a stream
inline std::ostream& operator<<(std::ostream& stream, Truckload& load)
{
  load.pCurrent = load.pHead;
  int count {};
  while (load.pCurrent)
  {
    std::cout << *(load.pCurrent->pPool);
    load.pCurrent = load.pCurrent->pNext;
    if (!(++count % 5)) std::cout << std::endl;
  }
  if (count % 5) std::cout << std::endl;
  return stream;
}
 
 
// Constructor
Truckload::Truckload(const std::vector< ptr<Pool> >& pools)
{
  for (auto pPool : pools)
  {
    addPool(pPool);
  }
}
 
// Add a Pool to the list
void Truckload::addPool(ptr<Pool> pPool)
{
  auto pPackage = std::make_shared<Package>(pPool);  // Create a Package
 
  if (pHead)                                        // Check  list is not  empty
    pTail->pNext = pPackage;                       // Add the  new  object  to  the  tail
  else                                              // List is empty
    pHead = pPackage;                               // so new  object  is the  head
 
  pTail = pPackage;                                 // Store  its address as tail
}
 
// Find the Package containing pPool and delete it from the list
bool Truckload::deletePool(ptr<Pool> pPool)
{
  pCurrent = pHead;                                 // Start at the first pool
  ptr<Package> pPrevious;                           // There's no previous pool to the 1st
  while (pCurrent)
  {
    if (pCurrent->pPool == pPool)                  // Check for identical Pool pointers
    { // We found the pool!
      if (pPrevious)                                 // If there's a previous pool...
      {
        pPrevious->pNext = pCurrent->pNext;      // ...set its next to be the pool after current
      }
      else                                            // It is the first pool...
      {
        pHead = pHead->pNext;                     // ..so make the next the first pool
      }
      pCurrent = nullptr;
      return true;
    }
    pPrevious = pCurrent;                             // Make current the previous pool...
    pCurrent = pCurrent->pNext;                   // ... and the next one current
  }
  return false;
}
 
// Get the first Pool
ptr<Pool> Truckload::getFirstPool()
{
  pCurrent = pHead->pNext;
  return pHead->pPool;
}
 
// Get the next Pool
ptr<Pool> Truckload::getNextPool()
{
  if (!pCurrent)                                     // If there's no current...
    return getFirstPool();                            // ...return the 1st
 
  auto pPackage = pCurrent->pNext;               // Save the next package
  if (pPackage)                                      // If there is one...
  {
    pCurrent = pPackage;                             // Update current to the next
    return pPackage->pPool;
  }
  pCurrent = nullptr;                                // If we get to here...
  return nullptr;                                    // ...there was no next
}
 
 
// Function to generate integral random pool dimensions from 1 to max_size
inline double random(double max_size)
{
  return 1 + static_cast<int>(max_size* static_cast<double>(std::rand()) / (RAND_MAX + 1.0));
}
 
int main()
{
  const double dimLimit {99.0};        // Upper limit on Pool dimensions
  std::srand((unsigned) std::time(0));  // Initialize the random number generator
  Truckload load;
  const int poolCount {20};          // Number of Pool object to be created
 
  // Create 20 Pool objects
  for (int i {}; i < poolCount; ++i)
    load.addPool(std::make_shared<Pool>(random(dimLimit), random(dimLimit), random(dimLimit)));
 
  std::cout << "The pools are:\n";
  std::cout << load;
 
  // Find the largest Pool in the  list
  double maxVolume {};
  int maxIndex {};
  int i {};
  while (load[i] )
  {
    if (load[i]->volume() > maxVolume)
    {
      maxIndex = i;
      maxVolume = load[i]->volume();
    }
    ++i;
  }
 
  std::cout << "\nThe largest pool is: ";
  std::cout << *load[maxIndex] << std::endl;
 
  load.deletePool(load[maxIndex]);
  std::cout << "\nAfter deleting the largest pool, the list contains:\n";
  std::cout << load;
}