/* Created 4/16/18 for Sandin Jayasekera's question: https://www.sololearn.com/Discuss/1219051 Operator Overloading C++ Can someone explain a real world example where I would need to overload an operator? Can you please also explain to me what exactly overloading sn operator is? Based on: https://code.sololearn.com/cB15chNqeV86 */ #include #include // Demostrate operator overloading. class Demo { private: int value; public: Demo(); Demo(int); Demo(const Demo&); int toInt(); Demo& operator=(const Demo&); Demo& operator++(); Demo operator++(int); Demo& operator--(); Demo operator--(int); Demo& operator+=(const Demo& rhs); Demo& operator+(); friend Demo operator+(Demo lhs, const Demo& rhs); Demo& operator-=(const Demo& rhs); Demo& operator-(); friend Demo operator-(Demo lhs, const Demo& rhs); Demo& operator*=(const Demo& rhs); friend Demo operator*(Demo lhs, const Demo& rhs); Demo& operator/=(const Demo& rhs); friend Demo operator/(Demo lhs, const Demo& rhs); Demo& operator%=(const Demo& rhs); friend Demo operator%(Demo lhs, const Demo& rhs); inline bool operator<(const Demo& rhs) { return value < rhs.value; } inline bool operator>(const Demo& rhs) { return value > rhs.value; } inline bool operator<=(const Demo& rhs) { return !(*this > rhs); } inline bool operator>=(const Demo& rhs) { return !(*this < rhs); } inline bool operator==(const Demo& rhs) { return value == rhs.value; } inline bool operator!=(const Demo& rhs) { return !(*this == rhs); } friend std::ostream& operator<<( std::ostream&, const Demo&); }; // Demo // Default constructor initializing with zero. Demo::Demo() { value = 0; } // Demo // Integer value constructor initializing with number. Demo::Demo(int number) { value = number; } // Demo // Copy constructor initializing with value of demo. Demo::Demo(const Demo& demo) { this->value = demo.value; } // Demo // Return the current value. int Demo::toInt() { return value; } // toInt // Assignment operator initializing with new instance // allocated with value of demo. Demo& Demo::operator=(const Demo& demo) { value = demo.value; return *this; } // operator= // Preincrement operator to increment and return. Demo& Demo::operator++() { value++; return *this; } // operator++ // Postincrement operator to copy, increment, and // return original. Demo Demo::operator++(int) { Demo* tmp = new Demo(value); operator++(); return *tmp; } // operator++ // Predecrement operator to decrement and return. Demo& Demo::operator--() { value--; return *this; } // operator++ // Postdecrement operator to copy, decrement, and // return original. Demo Demo::operator--(int) { Demo* tmp = new Demo(value); operator--(); return *tmp; } // operator++ // Plus assignment operator to add the two values // and return the updated instance. Demo& Demo::operator+=(const Demo& rhs) { value += rhs.value; return *this; } // operator+= // Unary plus operator. Demo& Demo::operator+() { Demo* tmp = new Demo(value); return *tmp; } // operator+ // Adding as a friend allows optimizations in // equation to allocate result once and reuse it. Demo operator+(Demo lhs, const Demo& rhs) { lhs += rhs; return lhs; } // operator+ // Minus assignment operator to subtract the two // values and return the updated instance. Demo& Demo::operator-=(const Demo& rhs) { value -= rhs.value; return *this; } // operator-= // Unary minus operator. Demo& Demo::operator-() { Demo* tmp = new Demo(-value); return *tmp; } // operator+ // Subtracting as a friend allows optimizations in // equation to allocate result once and reuse it. Demo operator-(Demo lhs, const Demo& rhs) { lhs -= rhs; return lhs; } // operator- // Multiply assignment operator to multiply the two // values and return the updated instance. Demo& Demo::operator*=(const Demo& rhs) { value *= rhs.value; return *this; } // operator*= // Multplying as a friend allows optimizations in // equation to allocate result once and reuse it. Demo operator*(Demo lhs, const Demo& rhs) { lhs *= rhs; return lhs; } // operator* // Divide assignment operator to divide the two values // and return the updated instance. Demo& Demo::operator/=(const Demo& rhs) { value /= rhs.value; return *this; } // operator/= // Dividing as a friend allows optimizations in // equation to allocate result once and reuse it. Demo operator/(Demo lhs, const Demo& rhs) { lhs /= rhs; return lhs; } // operator/ // Modulo assignment operator to modulo the two values // and return the updated instance. Demo& Demo::operator%=(const Demo& rhs) { value %= rhs.value; return *this; } // operator%= // Modulo as a friend allows optimizations in // equation to allocate result once and reuse it. Demo operator%(Demo lhs, const Demo& rhs) { lhs %= rhs; return lhs; } // operator% // Friend function to output value to the stream. std::ostream& operator<<( std::ostream& os, const Demo& demo) { os << demo.value; return os; } // operator<< int main() { Demo five = +Demo(5); assert(five == 5); std::cout << five << std::endl; // 5 Demo six = five + 1; assert(six == 6); std::cout << six << std::endl; // 6 Demo play = six / five; assert(play == 1); std::cout << play << std::endl; // 1 int n = 1 + five.toInt(); assert(n == 6); std::cout << n << std::endl; // 6 play *= n; assert(play == 6); std::cout << play << std::endl; // 6 if (-play >= five) { // false n = 1; play++; } else { n = 0; --play; } // if assert(n == 0); std::cout << n << std::endl; // 0 assert(play == 5); std::cout << play << std::endl; // 5 play %= 2; assert(play == 1); std::cout << play << std::endl; // 1 play = n + five + play - six; assert(play == 0); std::cout << play << std::endl; // 0 return 0; } // main

operator overload C++ mn oo