OpTemplate Class - A Demonstration of Operator Overloading

• Download source files - 1.86 Kb

Introduction

This is a very crude demonstration of operator overloading. It requires you to have a bit of knowledge on operator overloading before you can fully utilize this class. This class is useful for those who don't remember all the necessary ingredients for the overloading of each operator. It allows you to cut and paste the section of code that you want, and modify it to suit your needs.

The following listing shows both global operator overloading and class member operator overloading. If all the global functions are excluded, the Template class can be compiled. It is a working, although useless, class.

The comments "Reimplement" show those functions which require you to change the implementation before it can be used. Those which have "No change necessary" can be used straight without changing as they depend solely on those functions that need re-implementation unless you feel there is a need to change them to improve performance.

Nothing much more can be said about the listing. Any comments and improvements to the template are much welcome. Let's maintain this reference for all beginners together.

// Global functions: unary function @x
// (No change necessary if coupled
// with member overloaded operators)
template<class T> T operator+(T x) {return +x;}
template<class T> T operator-(T x) {return -x;}
template<class T> T operator*(T x) {return *x;}
template<class T> T operator&(T x) {return &x;}
template<class T> T operator!(T x) {return !x;}
template<class T> T operator~(T x) {return ~x;}
template<class T> T operator++(T x) {return ++x;}
template<class T> T operator--(T x) {return --x;}

// Global functions: unary functions x@
// (No change necessary if coupled with
// member overloaded operators)
template<class T> T operator++(T x, int) {return x++;}
template<class T> T operator--(T x, int) {return x--;}

// Global functions: binary functions
// (No change necessary if coupled
// with member overloaded operators)
template<class T> const T& operator+(const T& x, 
  const T& y) {T w(x); w += y; return w;}
template<class T> const T& operator-(const T& x, 
  const T& y) {T w(x); w -= y; return w;}
template<class T> const T& operator*(const T& x, 
  const T& y) {T w(x); w *= y; return w;}
template<class T> const T& operator/(const T& x, 
  const T& y) {T w(x); w /= y; return w;}
template<class T> const T& operator%(const T& x, 
  const T& y) {T w(x); w %= y; return w;}
template<class T> const T& operator^(const T& x, 
  const T& y) {T w(x); w ^= y; return w;}
template<class T> const T& operator&(const T& x, 
  const T& y) {T w(x); w &= y; return w;}
template<class T> const T& operator|(const T& x, 
  const T& y) {T w(x); w |= y; return w;}

// Global functions: binary functions

// Reimplement if not using member overloaded operators
template<class T> bool operator==(T x, T y) 
  const {return x == y;}
template<class T> bool operator< (T x, T y) 
  const {return x < y;}
  // Reimplement if not using member overloaded operators
template<class T> bool operator!=(T x, T y) 
  const {return !(x == y);} // No change necessary
template<class T> bool operator> (T x, T y) 
  const {return (y < x);} // No change necessary
template<class T> bool operator<=(T x, T y) 
  const {return !(y < x);} // No change necessary
template<class T> bool operator>=(T x, T y) 
  const {return !(x < y);} // No change necessary
template<class T> const T& operator<<(T x, T y)
  {return x << y;} // Reimplement
template<class T> const T& operator>>(T x, T y)
  {return x >> y;} // Reimplement
// Reimplement if not using member overloaded operators
template<class T> const T& operator&&(T x, T y)
  {return x && y;} 
// Reimplement if not using member overloaded operators
template<class T> const T& operator||(T x, T y)
  {return x || y;}
// Reimplement if not using member overloaded operators
template<class T> const T& operator,(T x, T y)
  {return x , y;}
template<class T> ostream& 
  operator<<(ostream& os, const T& x)
  {os << x; return (os);} // Reimplement
template<class T> istream& 
  operator>>(istream& is, T& x)
  {is >> x; return (is);} // Reimplement


template<class T>
class Template
{
public:
    // STL-like types
    typedef T            value_type;
    typedef T&           reference;
    typedef const T&     const_reference;
    typedef T*           pointer;
    typedef const T*     const_pointer;
    typedef T*           iterator;
    typedef const T*     const_iterator;
    typedef size_t       size_type;
    typedef ptrdiff_t    difference_type;

    // Return STL-like iterators
    iterator         begin()         {return this;}     
    const_iterator     begin() const    {return this;}
    iterator         end()         {return this;}       
    const_iterator     end() const     {return this;}
    size_type     size() const     {return size_;}

    Template(size_t size=0) : size_(size)
            {memberA = new value_type[size];}
    Template(const Template& y) {*this=y;}
    ~Template() {delete[] memberA;}


    // Unary operators
    const Template& operator+() const 
      {+member; return *this;} // Reimplement
    const Template& operator-() const 
      {~member + 1; return *this;} // Reimplement
    const Template& operator*() const 
      {member; return *this;} // Reimplement
    const Template& operator&() const 
      {&member; return *this;} // Reimplement
    const Template& operator~() const 
      {~member; return *this;} // 1's complement (Reimplement)
    const Template& operator!() const 
      {!member; return *this;} // Reimplement
    pointer operator->() {return memberA;} // Reimplement

    // Increment and decrement operators
    const Template& operator++()    
      {++member; return *this;} // Prefix (Reimplement)
    const Template& operator--() 
      {--member; return *this;} // Prefix (Reimplement)
    Template& operator++(int) 
      {Template w(*this); ++*this; return w;}
      // Postfix (No change necessary)
    Template& operator--(int) 
      {Template w(*this); ++*this; return w;}
      // Postfix (No change necessary)

    // Assignment operators
    const Template& operator=(const Template& y) // Reimplement
    {
        if (this != &y) // make sure not same object
        {
            member = y.member;
            size_ = y.size_;
            // free member variables' memory
            delete[] memberA;
            // get new memory for member variables
            memberA = new value_type[y.size_];
            // copy value for member variables from y
            memberA = y.memberA;
        }
        return *this; // return ref for multiple assignment
    }
    Template& operator+= (const Template& y) 
      {member += y.member; return *this;} // Reimplement
    Template& operator-= (const Template& y) 
      {member -= y.member; return *this;} // Reimplement
    Template& operator*= (const Template& y) 
      {member *= y.member; return *this;} // Reimplement
    Template& operator/= (const Template& y) 
      {member /= y.member; return *this;} // Reimplement
    Template& operator%= (const Template& y) 
      {member %= y.member; return *this;} // Reimplement
    Template& operator<<=(size_t y) 
      {member <<= y; return *this;} // Reimplement
    Template& operator>>=(size_t y) 
      {member >>= y; return *this;} // Reimplement
    Template& operator&= (const Template& y) 
      {member &= y.member; return *this;} // Reimplement
    Template& operator|= (const Template& y) 
      {member |= y.member; return *this;} // Reimplement
    Template& operator^= (const Template& y) 
      {member ^= y.member; return *this;} // Reimplement

    // Binary operators
    Template operator+(const Template& y) const
      {Template w(y); w += *this; return w;} 
      // Addition  (No change necessary)
    Template operator-(const Template& y) const
      {Template w(y); w -= *this; return w;} 
      // Subtraction  (No change necessary)
    Template operator*(const Template& y) const
      {Template w(y); w *= *this; return w;} 
      // Multiplication  (No change necessary)
    Template operator/(const Template& y) const
      {Template w(y); w /= *this; return w;} 
      // Division  (No change necessary)
    Template operator%(const Template& y) const
      {Template w(y); w %= *this; return w;} 
      // Modulo  (No change necessary)
    Template operator&(const Template& y) const
      {Template w(y); w &= *this; return w;} 
      // Binary And  (No change necessary)
    Template operator|(const Template& y) const
      {Template w(y); w |= *this; return w;} 
      // Binary Or  (No change necessary)
    Template operator^(const Template& y) const
      {Template w(y); w ^= *this; return w;} 
      // Binary Xor  (No change necessary)
    Template operator<<(size_t y) const
      {Template w(y); w <<= y; return w;}
      // Left shift (No change necessary)
    Template operator>>(size_t y) const 
      {Template w(y); w >>= y; return w;}
	  // Right shift (No change necessary)
	Template operator&&(const Template& y) const 
	  {Template w(y); member && y.member; return w;} 
	  // Reimplement
	Template operator||(const Template& y) const 
	  {Template w(y); member || y.member; return w;} 
	  // Reimplement
	Template operator,(const Template& y) const 
	  {Template w(y); member , y.member; return w;} 
	  // Reimplement

	// Comparison operators
	bool operator==(const Template& y) const 
	  {return (member == y.member);} // Reimplement
	bool operator< (const Template& y) const 
	  {return (member < y.member);}  // Reimplement
	bool operator!=(const Template& y) const 
	  {return !(*this == y);} // No change necessary
    bool operator> (const Template& y) const 
      {return (y < *this);} // No change necessary
    bool operator<=(const Template& y) const 
      {return !(y < *this);} // No change necessary
    bool operator>=(const Template& y) const 
      {return !(*this < y);} // No change necessary

    // Member access
    reference operator[](size_type index) 
      {return memberA[index];} // Reimplement
    const_reference operator[](size_type index) 
      const {return memberA[index];} // Reimplement

    // Streams
    friend ostream& operator<<(ostream& os, 
      const Template& y)
      {os << y.member; return os;} // Reimplement
    friend istream& operator>>(istream& is, 
      Template& y) {is >> y.member; return is;} 
      // Reimplement

    // Functor 
    const Template& operator()(Template& y) 
      {*this * y; *this / y; return *this;} // Reimplement

    // Misc
    Template& operator->*(Template& y) 
      {return *this;} // Reimplement

    // Memory management
    void* operator new(size_t size) 
      {return ::new Template;} // Reimplement
    void* operator new(size_t n, T extra) 
      {return ::new Template;} // Reimplement
    void* operator new[](size_t size) 
      {return ::new Template[size];} // Reimplement            
    void* operator new[](size_t index, T extra) 
      {return ::new Template[size];} // Reimplement
    void  operator delete(void *p) 
      {::delete reinterpret_cast<Template*>(p);}
      // Reimplement
    void  operator delete(void *p, size_t size) 
      {::delete reinterpret_cast<Template*>(p);}
      // Reimplement
    void  operator delete[](void *p) 
      {::delete[] reinterpret_cast<Template*>(p);}
      // Reimplement                          
    void  operator delete[](void *p, size_t size) 
      {::delete[] reinterpret_cast<Template*>(p);}
      // Reimplement
    void  operator delete[](void *p, T extra) 
      {::delete[] reinterpret_cast<Template*>(p);}
      // Reimplement
    
private:
    T member; // Reimplement
    T* memberA; // Reimplement
    size_t size_; // Reimplement
};