Chapter 6: More About Operator Overloading

Now that we've covered the overloaded assignment operator in depth, and now that we've seen some examples of other overloaded operators as well (i.e., the insertion and extraction operators), let's take a look at some other interesting examples of operator overloading.

6.1: Overloading operator[]()

An example of the use of the class is given here:

    int main()
    {
        IntArray
            x(20);              // 20 ints

        for (int i = 0; i < 20; i++)
            x[i] = i * 2;       // assign the elements
                   
                                // produces boundary
                                // overflow
        for (int i = 0; i <= 20; i++)
            cout << "At index " << i << ": value is " << x[i] << endl;

        return (0);
    }

We give the following class interface:

    class IntArray
    {
         public:
            IntArray(int size = 1);     // default size: 1 int
            IntArray(IntArray const &other);
            ~IntArray();
            IntArray const &operator=(IntArray const &other);

                            // overloaded index operators:
            int &operator[](int index);         // first
            int operator[](int index) const;    // second
        private:
            void destroy();             // standard functions
                                        // used to copy/destroy
            void copy(IntArray const &other);

            int 
                *data, 
                size;
    };

• The class has a constructor with a default int argument, specifying the array size. This function serves also as the default constructor, since the compiler will substitute 1 for the argument when none is given.

  
  

• The class internally uses a pointer to reach allocated memory. Hence, the necessary tools are provided: a copy constructor, an overloaded assignment function and a destructor.

  
  

• Note that there are two overloaded index operators. Why are there two of them ?

  
  The first overloaded index operator allows us to reach and obtain the elements of the IntArray object.

  
  This overloaded operator has as its prototype a function that returns a reference to an int. This allows us to use expressions like x[10] on the left-hand side and on the right-hand side of an assignment.

  
  We can therefore use the same function to retrieve and to assign values. Furthermore note that the returnvalue of the overloaded array operator is not a int const &, but rather a int &. In this situation we don't want the const, as we must be able to change the element we want to access, if the operator is used as a left-hand value in an assignment.

  
  However, this whole scheme fails if there's nothing to assign. Consider the situation where we have an IntArray const stable(5);. Such an object is a const object, which cannot be modified. The compiler detects this and will refuse to compile this object definition if only the first overloaded index operator is available. Hence the second overloaded index operator. Here the return-value is an int, rather than an int &, and the member-function itself is a const member function. This second form of the overloaded index operator cannot be used with non-const objects, but it's perfect for const objects. It can only be used for value-retrieval, not for value-assignment, but that is precisely what we want with const objects.

  
  

• We used the standard implementations of the copy constructor, the overloaded assignment operator and the destructor, discussed before (in section 5.4.1), albeit that we've left out the implementation of the function destroy(), as this function would consist of merely one statement (delete data).

  
  

• As the elements of data are ints, no delete [] is needed. It does no harm, either. Therefore, since we use the [] when the object is created, we also use the [] when the data are eventually destroyed.

  
  

The member functions of the class are presented next.

    IntArray::IntArray(int sz)
    {
        if (sz < 1)
        {
            cout << "IntArray: size of array must be >= 1, not " << sz
                 << "!" << endl;
            exit(1);
        }
        // remember size, create array
        size = sz;
        data = new int [sz];
    }

    // copy constructor
    IntArray::IntArray(IntArray const &other)
    {    
        copy(other);
    }
    
    // destructor
    IntArray::~IntArray()
    {    
        delete [] data;
    }
    
    // overloaded assignment
    IntArray const &IntArray::operator=(IntArray const &other)
    {
        // take action only when no auto-assignment
        if (this != &other)
        {
            delete [] data;
            copy(other);
        }
        return (*this);
    }

    // copy() primitive
    void IntArray::copy(IntArray const &other)
    {
        // set size
        size = other.size;

        // create array
        data = new int [size];

        // copy other's values
        for (register int i = 0; i < size; i++)
            data[i] = other.data[i];
    }

    // here is the overloaded array operator
    int &IntArray::operator[](int index)
    {
        // check for array boundary over/underflow
        if (index < 0 || index >= size)
        {
            cout << "IntArray: boundary overflow or underflow, index = " 
                 << index << ", should range from 0 to " << size - 1 << endl;
            exit(1);
        }
        return (data[index]);   // emit the reference
    }

6.2: Overloading operator new(size_t)

It is also possible to define multiple versions of the operator new, as long as each version has its own unique set of arguments. The global new operator can still be used, through the ::-operator. If a class X overloads the operator new, then the system-provided operator new is activated by

Furthermore, the new [] construction will always use the default operator new.

An example of the overloaded operator new for the class X is the following:

                        
    #include <stddef.h>

    void *X::operator new(size_t sizeofX)
    {
        void
            *p = new char[sizeofX];
            
        return (memset(p, 0, sizeof(X)));
    } 

Now, what happens when the operator new is defined for the class X, assuming that class is defined as follows (For the sake of simplicity we have violated the principle of encapsulation here. The principle of encapsulation, however, is immaterial to the discussion of the workings of the operator new.):

    class X
    {
        public:
            void *operator new(size_t sizeofX);

            int
                x,
                y,
                z;
    };

Next, consider the following program fragment:

    #include "X.h"  // class X interface etc.
    
    int main()
    {
        X
            *x = new X();
            
        cout << x.x << ", " << x.y << ", "<< x.z << endl;
        return (0);
    }

This small program produces the following output:

Our little program performed the following actions:

• First, operator new was called, which allocated and initialized a block of memory, the size of an X object.
• Next, a pointer to this block of memory was passed to the (default) X() constructor. Since no constructor was defined, the constructor itself didn't do anything at all.

Non-static object member functions are passed a (hidden) pointer to the object on which they should operate. This hidden pointer becomes the this pointer inside the memberfunction. This procedure is also followed by the constructor. In the following fragments of pseudo C++ the pointer is made visible. In the first part an X object is declared directly, in the second part of the example the (overloaded) operator new is used:

        X::X(&x);   // x's address is passed to the constructor
                    // the compiler made 'x' available

        void        // ask new to allocate the memory for an X
            *ptr = X::operator new();
        X::X(ptr);  // and let the constructor operate on the
                    // memory returned by 'operator new'

    int main()
    {
        X
            x;

        X::operator new(sizeof x);

        return (0);
    }

The operator new can have multiple parameters. The first parameter again is the size_t parameter, other parameters must be passed during the call to the operator new. For example:

    class X
    {
        public:
            void *operator new(size_t p1, unsigned p2);
            void *operator new(size_t p1, char const *fmt, ...);
    };
    
    int main()
    {
        X
            *object1 = new(12) X(),
            *object2 = new("%d %d", 12, 13) X(),
            *object3 = new("%d", 12) X();

        return (0);
    }

6.3: Overloading operator delete(void *)

Therefore, in a class the operator delete may be overloaded using the following prototype:

or

The `home-made' delete operator is called after executing the class' destructor. So, the statement

with ptr being a pointer to an object of the class X for which the operator delete was overloaded, boils down to the following statements:

    X::~X(ptr);     // call the destructor function itself

                    // and do things with the memory pointed
                    // to by ptr itself.
    X::operator delete(ptr, sizeof(*ptr));

The overloaded operator delete may do whatever it wants to do with the memory pointed to by ptr. It could, e.g., simply delete it. If that would be the preferred thing to do, then the default delete operator can be activated using the :: scope resolution operator. For example:

    void X::operator delete(void *ptr)
    {
        // ... whatever else is considered necessary
                     
        // use the default operator delete 
        ::delete ptr;
    }

6.4: Cin, cout, cerr and their operators

The implementation of an overloaded operator << in the context of cout or cerr involves the base class of cout or cerr, which is ostream. This class is declared in the header file iostream.h and defines only overloaded operator functions for `basic' types, such as, int, char*, etc.. The purpose of this section is to show how an operator function can be defined which processes a new class, say Person (see chapter 5.1) , so that constructions as the following one become possible:

    Person
        kr("Kernighan and Ritchie", "unknown", "unknown");

    cout << "Name, address and phone number of Person kr:\n"
         << kr
         << '\n';

The statement cout << kr involves the operator << and its two operands: an ostream & and a Person &. The proposed action is defined in a class-less operator function operator<<() expecting two arguments:

    // declaration in, say, person.h
    ostream &operator<<(ostream &, Person const &);

    // definition in some source file
    ostream &operator<<(ostream &stream, Person const &pers)
    {
        return 
        (
            stream << "Name:    " << pers.getname()
                   << "Address: " << pers.getaddress()
                   << "Phone:   " << pers.getphone()
        );
    }

Concerning this function we remark the following:

• The function must return a (reference to) ostream object, to enable `chaining' of the operator.

  
  

• The two operands of the operator << are stated as the two arguments of the overloading function.

  
  

• The class ostream provides the member function opfx(), which flushes any other ostream streams tied with the current stream. opfx() returns 0 when an error has been encountered (Cf. chapter 9).

  
  An improved form of the above function would therefore be:

  
  

  
      ostream &operator<<(ostream &stream, Person const &pers)
      {
          if (! stream.opfx())
              return (stream);
          ...
      }
  
  

  
  

6.5: Conversion operators

class String
{
    public:
        String();
        String(char const *arg);
        ~String();            
        String(String const &other);
        String const &operator=(String const &rvalue);
        String const &operator=(char const *rvalue);
    private:
        char
            *string;
};

Usually, in classes that are less directly linked to their data than this String class, there will be an accessor member function, like char const *String::getstr() const. However, in the current context that looks a bit awkward, but it also doesn't seem to be the right way to go when an array of strings is defined, e.g., in a class StringArray, in which the operator[] is implemented to allow the access of individual strings. Take a look at the following class interface:

class StringArray
{
    public:
        StringArray(unsigned size);
        StringArray(StringArray const &other);
        StringArray const &operator=(StringArray const &rvalue);
        ~StringArray();            

        String &operator[](unsigned index);
    private:
        String
            *store;
        unsigned
            n;
};

The StringArray class has one interesting memberfunction: the overloaded array operator operator[]. It returns a String reference.

Using this operator assignments between the String elements can be realized:

    StringArray
        sa(10);             
        
    ... // assume the array is filled here
    
    sa[4] = sa[3];  // String to String assignment

It is also possible to assign a char const * to an element of sa:

• First, sa[3] is evaluated. This results in a String reference.
• Next, the String class is inspected for an overloaded assignment, expecting a char const * to its right-hand side. This operator is found, and the string object sa[3] can receive its new value.

Now we try to do it the other way around: how to access the char const * that's stored in sa[3]? We try the following code:

    char const
        *cp;
        
    cp = sa[3];

The naive solution is to resort to the accessor member function getstr():

A conversion operator is a kind of overloaded operator, but this time the overloading is used to cast the object to another type. Using a conversion operator a String object may be interpreted as a char const *, which can then be assigned to another char const *. Conversion operators can be implemented for all types for which a conversion is needed.

In the current example, the class String would need a conversion operator for a char const *. The general form of a conversion operator in the class interface is:

The implementation of the conversion operator is straightforward:

    String::operator char const *()
    {
        return (string);
    }

Notes:

• There is no mentioning of a return type. The conversion operator has the type of the returned value just after the operator keyword.
• In certain situations the compiler needs a hand to disambiguate our intentions. In a statement like printf("%s", sa[3]); the compiler is confused: are we going to pass a String & or a char const * to the printf() function? To help the compiler out, we supply an explicit cast here: printf("%s", (char const *)sa[3]);

For completion, the final String class interface, containing the conversion operator, looks like this:

class String
{
    public:
        String();
        String(char const *arg);
        ~String();            
        String(String const &other);
        String const &operator=(String const &rvalue);
        String const &operator=(char const *rvalue);
        operator char const *();
    private:
        char
            *string;
};

6.6: Overloadable Operators

    +       -       *       /       %       ^       &       |
    ~       !       ,       =       <       >       <=      >=
    ++      --      <<      >>      ==      !=      &&      ||
    +=      -=      *=      /=      %=      ^=      &=      |=
    <<=     >>=     []      ()      ->      ->*     new     delete

However, some of these operators may only be overloaded as member functions within a class. This holds true for the '=', the '[]', the '()' and the '->' operators. Consequently, it isn't possible to redefine, e.g., the assignment operator globally in such a way that it accepts a char const * as an lvalue and a String & as an rvalue. Fortunately, that isn't necessary, as we have seen in section 6.5.