Implementing the % operator for the Pool class to produce the volume left after dividing one Pool object into another. - C++ Class

C++ examples for Class:Operator Overload

  1. HOME
  2. C++
  3. Class
  4. Operator Overload

Description

Implementing the % operator for the Pool class to produce the volume left after dividing one Pool object into another.

Demo Code

#include <iostream>
#include <iostream>
#include <iomanip>

class  Pool{// w w w .  j  a  v  a 2  s .  co  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
  Pool operator*(int n) const;                                       // Post-multiply an object by an integer
  int operator/(const Pool& aPool) const;                             // Function to divide one Pool object by another
  double operator%(const Pool& aPool) const;                             // Volume left after dividing one Pool object by another

  friend std::ostream& operator<<(std::ostream& stream, const Pool& pool);
};

inline double Pool::operator%(const Pool& pool) const
{
  int n {*this / pool};
  return volume() - n*pool.volume();
}

inline int Pool::operator/(const Pool& pool) const
{
  // Lambda expression to calculate division for a given orientation of pool
  auto trial = [this](double L, double W, double H){ return static_cast<int>(this->length / L)*
    static_cast<int>(this->width / W)*
    static_cast<int>(this->height / H); };

  int result {trial(pool.length, pool.width, pool.height)};                    // pool in LxWxH orientation
  if (!result) return 0;

  int temp {trial(pool.length, pool.height, pool.width)};                      // pool in LxHxW orientation
  if (temp > result)result = temp;

  temp = trial(pool.width, pool.height, pool.length);                             // pool in WxHxL orientation
  if (temp > result)result = temp;

  temp = trial(pool.width, pool.length, pool.height);                             // pool in WxLxH orientation
  if (temp > result)result = temp;

  temp = trial(pool.height, pool.length, pool.width);                             // pool in HxLxW orientation
  if (temp > result)result = temp;

  temp = trial(pool.height, pool.width, pool.length);                             // pool in HxWxL orientation
  if (temp > result)result = temp;
  return result;
}

// Pre-multiply an object by an integer
inline Pool operator*(int n, Pool& pool)
{
  return Pool {pool.getLength(), pool.getWidth(), n*pool.getHeight()};
}

// Post-multiply an object by an integer
inline Pool Pool::operator*(int n) const
{
  return Pool {length, width, n*height};
}

// 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};
}

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;
}

int main()
{
  Pool pool1 {12, 5, 12};
  Pool pool2 {3, 4, 5};
  Pool pool3 {5, 4, 5};
  std::cout << "pool1 is " << pool1 << std::endl;
  std::cout << "pool2 is " << pool2 << std::endl;
  std::cout << "Volume of pool1 is " << pool1.volume() << std::endl;
  std::cout << "Volume of pool2 is " << pool2.volume() << std::endl;

  int n {pool1 / pool2};
  std::cout << "pool1/pool2 is " << n << std::endl;
  std::cout << "With " << n << " of pool2 in pool1, the space left is " << pool1%pool2 << std::endl;

  n = pool1 / pool3;
  std::cout << "pool1/pool3 is " << n << std::endl;
  std::cout << "With " << n << " of pool3 in pool1, the space left is " << pool1%pool3 << std::endl;
}

Result


Related Tutorials