When a class is designed a new data type is being added to the C++ language. The ability to overload a C++ operator allows the programmer to define the meaning of operators relative to the class being defined. Operators are overloaded and selected based on the signature- matching algorithm for finding overloaded functions. The keyword operator is used to define a type conversion member function. It is also used to overload the built-in C operators. Just as a function name can be given a variety of meanings, with each meaning being different depending upon the arguments being passed, so can an operator, such as +, be given additional meanings. Overloading operators allows infix expressions of both ADTs and built-in types to be written. It is an important notational convenience and in many instances leads to shorter and more readable programs.
Defining operators for a class is easy once you know how the application of an operator is translated to a function call. For a unary operator such as &, when you write the following:
where X is an instance of some class, the C++ compiler applies the operator by calling this function:
X.operator&()
The compiler automatically passes a pointer to the class instance to the function. For binary operators such as +, an expression such as this:
X + Y
where X and Y are class instances, the compiler calls the function:
X.operator+(Y)
As you can see, the C++ compiler reduces the application of operators to function calls. Thus, you can overload an operator by defining a function whose name begins with the keyword operator followed by the symbolic notation of that operator.
Like all member functions, operator functions receive a pointer to the class instance in the hidden argument named this. Because this argument is implicit, unary operator functions are defined with no arguments at all. Binary operator functions that are members of the class take a single argument, which is the right- hand side of the operator expression. The ternary operator, ?:, cannot be overloaded. However, you can define an operator function as a friend instead of as a member function of the class. By defining an operator overload function as a friend, the class instance pointer is not passed to the function. There are times when the programmer needs to define friend operator functions. When declared as a friend, the operator function requires all arguments explicitly. Thus, to declare operator+ as a friend function of class X, the following would be written:
friend X operator+(X&, Y&); // assume X is a class
and thereafter, to evaluate the expression x1 + x2 for two instances of class X, the C++ compiler will call the function operator+(x1, x2).
All C++ operators can be overloaded except for the following:
Member access operator x.y
Dereferencing pointer to member x.*y
Scope resolution operator x::y
Conditional operator x?y:z
Those that can be overloaded are:
+ - * / % ^ & |
- ! , = < > <= >=
++ -- << >> == != && ||
+= -= /= %= ^= &= |= <<=
>>= [] () -> new delete
Although C++ enables the programmer to redefine the meaning of most of the built-in operator symbols for a class, there is no ability to change the precedence rules that dictate the order in which operators are evaluated. C++ operators have the same precedence as those of their ANSI C counterparts. Even if, for some class, the programmer were to define operators + and * to have entirely different meanings from addition and multiplication, in an expression such as this:
a + b * c // a, b, c are some class instances
the C++ compiler will still invoke the operator* function to evaluate b * c before calling operator+. The following tips will help in designing classes with overloaded operators (assume that a and b are instances of appropriate class types).
#. C++ does not “understand” the meaning of an overloaded operator. It’s the programmer’s responsibility to provide meaningful overloaded functions. #. C++ is not able to derive complex operators from simple ones. For instance, if you define overloaded operator functions operator* and operator=, C++ cannot evaluate the expression a *= b correctly. #. The programmer may never change the syntax of an overloaded operator. Operators that are binary must remain binary. Unary operators must remain unary. #. The programmer cannot invent new operators for use in expressions. Only those operators listed for the syntax of the language can be overloaded. However, the programmer can always write functions for special cases. #. The programmer may overload the operators ++ and –.
As an example of operator overloading, consider the + operator, the binary version, for the CString class. A good interpretation of this operator for the CString class would be to concatenate two CString objects. A typical use of the + operator for CString might be this:
CString s1("This "), s2("and that"), s3;
s3 = s1+s2;
The programmer can get this functionality by defining the following function as a member of the CString class;
// *********************************************************
// overload +
// Member function to concatenate two String objects
CString& CString::operator+( const CString& str )
{
size_t lgth = len + str.len;
char *t = new char[lgth + 1];
strcpy( t, s );
strcat( t, str.s );
return CString(t);
}
Because this version of the operator+ is a member function of the CString class, it takes only one argument, a reference to the CString on the right-hand side of the + operator. The function returns a new CString object that is a concatenation of the two CString items that are being added. Although the member function operator+ works well when adding CString items, it cannot handle another type of use for the operator. Because a CString is meant to model a dynamic array of characters, it is natural to allow the use of the operator in expressions such as this:
CString str = "World!".
CString s2 = "Hello, "+ str; // expecting "Hello, World!"
In this case, the C++ compiler will interpret the right-hand side of the expression as the following:
"Hello".operator+(str)
This is an error, because “Hello” is not an instance of a class and therefore has no member operator+ function that can be applied to “Hello”. One might think that a solution would be to convert “Hello” to a CString and then apply the operator+ function of the CString class. But, this does not happen because the C++ compiler does not automatically convert the left-hand operand of any member operator functions. However, if the programmer were to define a nonmember friend operator+ function in the CString class:
friend CString operator+(const char *s1, const String& s2);
the compiler would convert the expression call this function with the pointer to “Hello” as the first argument and str as the second argument. This would evaluate to the following function call:
operator+("Hello", str)
The definition of the friend operator+ function is similar to the member function, except that it does not take an implied pointer to the current instance of the class as the first argument, and the body of the function has to refer to each argument explicitly. Following is a definition of the function:
//***********************************************************
// CString concatenation operator, declared as "friend"
CString operator+(const char *a, CString ) // overload
{
CString temp;
strcpy( temp.s, a );
if( (strlen(a) + b.len ) < MAXLEN )
{
strcat( temp.s, b.s );
temp.len = strlen( temp.s );
}
else
cerr << "Max length exceeded in concatenation.\n";
return temp;
}
When copying one class instance to another instance of a compatible type, the results can be unexpected. C++ makes copies of instances not only in assignment expressions but at other times. So you must be aware of the consequences of copying class instances, even if you do not explicitly assign them with the = operator. There are four times when a copy of a class instance will be made:
#. When one instance is used to initialize a newly defined instance of the same class. #. When an instance is passed to a function’s value parameter of the class type. #. When a function returns a class instance (not a reference or pointer to the class). #. When a statement assigns one instance to another.
The first three of these cases initialize new copies of class instances using the value of an existing instance. The fourth case assigns the value of an existing instance to another instance that was previously defined. In all cases, the result is an object that contains copies of the data fields of another object. After making such copies, all may seem well, but trouble lurks unseen when the class instances contain pointer fields that address variables allocated space on the heap. Problems can also arise when creating copies of instances that contain fields of other class types, which may contain their own pointer fields. If two or more pointers happen to address the same location in memory, deleting one of those pointers will cause the others to address invalid data. Worse, deleting the same space more than once can corrupt the heap and cause a major bug. Because classes often inherit properties of many other classes, a simple assignment or function call might create dozens of duplicate pointers. And if those pointers address instances were allocated by new, class destructors might deallocate the same memory spaces multiple times, which will almost always corrupt the heap. To avoid such problems, the programmer should always provide a copy constructor for any class that includes dynamically allocated members.
// *********************************************************
// CString(const String&)
// Create a new CString as a copy of another CString
// This is called the "copy constructor"
CString::CString( const CString& str )
{
len = s.len;
maxlen = s.maxlen;
s = new char[maxlen];
strcpy( s, str.s );
}
When the programmer starts to define his/her own classes such as the CString class, he/she might want to overload the definitions of the << and >> operators so that they work with the class. For example, once the >> operator is overloaded, it is possible to read characters from an input stream into a CString object by writing:
CString user_input;
cin >> user_input; // accept user's input
Similarly, to display a CString, the programmer would write the following:
CString greetings = "Hello, World!";
cout << greetings << endl;
The stream extraction operator, >>, is easy to implement. The following version assumes a maximum string length of 256 characters including the null byte and uses the get function of the input stream to read in the characters into an internal array. Then it creates a new CString object from that character array and returns the CString.
//***********************************************************
// Stream extraction operator for CString class
istream& operator>>(istream& is, CString& str)
{
char buf[MAXLEN];
if( is.get(buf,MAXLEN) )
str = String( buf );
return is;
}
To overload the insertion operator, <<, a public member function is needed for the class that can handle the actual output. For the CString class, a print function is defined that performs the output as follows:
//***********************************************************
// Output the CString to the specified output stream
void CString::print( ostream& os ) const
{
os << s ;
}
Once the print function is defined, you can overload the << operator for a CString argument as follows:
//***********************************************************
// Stream insertion operator for CString class
ostream& operator<<(ostream& os, String& str)
{
str.print( os );
return os;
}
As can be seen, this operator function does its work by calling the member function named print within the Cstring class. Note that the ostream class declares operator<< as a friend function.
Templates, also called generics or parameterized types, allow the programmer to construct a family of related functions or classes.
Consider a function max(x,y) that returns the larger of its two arguments, x and y can be of any type that has the ability to be ordered. But, since C++ is a strongly typed language, it expects the types of the parameters x and y to be declared at compile time. Without using templates, many overloaded versions of max() are required, one for each data type to be supported, even though the code for each version is essentially identical. Each version compares the arguments and returns the larger. For example,
int max( int x, int y )
{
return ( x < y) ? x : y ;
}
long max( long x, long y )
{
return ( x > y) ? x : y;
}
One way around this problem is to use a macro:
#define max(x,y) ((x>y) ? x : y )
However, using the #define circumvents the type-checking mechanism that makes C++ such an improvement over C. In fact, this use of macros is almost obsolete in C++. Clearly, the intent of max(x,y) is to compare compatible types. Unfortunately, using the macro allows a comparison between an int and a struct, which are incompatible. Another problem with the macro approach is that substitution will be performed where it is not desired:
class Foo
{
public:
int max(int, int); // syntax error; this gets expanded
};
By using a template instead, the programmer can define a pattern for a family of related overloaded functions by letting the data type itself be a parameter:
template <class T>
T max( T x, T y )
{
return ( x > y ) ? x : y ;
}
The data type is represented by the template argument: <class T>. When used in an application, the compiler generated the appropriate function according to the data type actually used in the call:
int i;
Myclass a, b;
int j = max(i,0); // arguments are integers
Myclass m = max(a,b); // arguments are type Myclass
Any data type (not just a class) can be used for <class T>. The compiler takes care of calling the appropriate operator>(), so that the call to max can be used with arguments of any type for which operator>() is defined.
A class template (also called a generic class or class generator) allows the programmer to define a pattern for class definitions. Generic container classes are good examples. Consider the following example of a stack class. Whether the stack is for integers, character strings or of any other type, the basic operations performed on the type are the same (insert, delete, index, and so on). With the element type treated as a type parameter to the class, the system will generate type-safe class definitions on the fly:
// *************************************************************
// Interface File : CStack.h
// Implementation File : CStack.cpp
// Description : A template class that implements
// : a stack.
// *************************************************************
// #pragma interface
#ifndef _CSTACK_H
#define _CSTACK_H
#include <string.h>
// #ifndef _BOOL
// #define _BOOL
// enum bool { false, true };
// #endif
template<class T>
class CStack
{
protected:
//
// Structure that describes each Node of the linked list
//
struct StackNode
{
T nodeData;
StackNode *next;
};
unsigned _cnt; // count of nodes in the stack
bool _newErr; // error indicator for new
StackNode *_tos; // pointer to the top of the stack
CStack& copy( CStack& );
public:
//
// Constructors
//
CStack();
//
// Destructors
//
~CStack();
//
// Accessors
//
bool isempty() const
{
return ( _cnt == 0 ) ? true : false;
}
bool getNewErr() const
{
return _newErr;
}
//
// Mutators
//
void push( T );
bool pop( T& );
void clean( void );
CStack& operator=( CStack& item )
{
copy( item );
return *this;
}
};
#endif
// *************************************************************
// Interface File : CStack.h
// Implementation File : CStack.h
// Description : Contructs a template class for a
// : stack;
// *************************************************************
// #pragma implementation
// #include "cstack.h"
template
CStack::CStack()
{
_cnt = 0;
_newErr = false;
_tos = NULL;
}
template
CStack::~CStack()
{
clean();
}
template
CStack& CStack::copy( CStack& item )
{
StackNode *current, *nextNode, *temp;
//
// clear the stack if not already empty
//
if( _tos )
clean();
//
// copy the data members across
//
_cnt = item._cnt;
_newErr = item._newErr;
//
// assign NULL to the top of stack pointer
//
_tos = NULL;
//
// exit if the source is empty
//
if( !item._tos )
return *this;
//
// allocate a new stack element
//
_tos = new StackNode;
//
// exit if error in allocation
//
if( !_tos )
{
_newErr = true;
return *this;
}
//
// initialize pointers to copy all of stack
//
_tos->next = NULL;
_tos->nodeData = item._tos->nodeData;
nextNode = item._tos->next;
current = _tos;
//
// duplicate the source stack elements
//
while( nextNode )
{
//
// create a new stack
//
temp = new StackNode;
if( !temp )
{
_newErr = true;
return *this;
}
//
// copy data
//
temp->nodeData = nextNode->nodeData;
temp->next = NULL;
current->next = temp;
current = current->next;
nextNode = nextNode->next;
}
return *this;
}
template
void CStack::clean()
{
T temp;
//
// pop everything from the stack
//
while( pop(temp) );
}
template
void CStack::push( T item )
{
StackNode *temp;
_newErr = false;
//
// first node on the stack?
//
if( _tos ) // no
{
//
// get a new stack node
//
temp = new StackNode;
if( !temp )
{
_newErr = true;
return;
}
temp->nodeData = item;
temp->next = _tos;
_tos = temp;
}
else // yes
{
_tos = new StackNode;
if( _tos == NULL )
{
_newErr = true;
return;
}
_tos->nodeData = item;
_tos->next = NULL;
}
++_cnt;
}
template
bool CStack::pop( T& item )
{
StackNode *temp;
//
// anything in the stack?
//
if( _cnt )
{
//
// save the data being popped into the reference
// data item
//
item = _tos->nodeData;
//
// save the current top of stack address
//
temp = _tos;
//
// move top of stack to the next node on the list
//
_tos = _tos->next;
//
// delete the old top of stack
//
delete temp;
//
// decrement the count of nodes
//
--_cnt;
return true;
}
else
return false;
}
Notice that in the above example that both the interface and the implementation appear in the header file. There is no separate .cpp file that holds the implementation. Most compilers require that both the interface code and the implementation be in one file for templates.
// ************************************************************
// Source File : tstack.cpp
// Description : Test program to exercise the parametric
// : class CStack.
// ************************************************************
#include
#include "cstack.h"
#include "cstring.h"
int main()
{
CStack myData;
int values[5];
int ch;
cout << "Enter 5 integers: ";
cin >> values[0] >> values[1] >> values[2]
>> values[3] >> values[4];
for( int i = 0; i < 5; ++i )
myData.push( values[i] );
for( i = 0; i < 5; ++i )
{
myData.pop( values[i] );
cout << "Value at[ " << i << " ]= "
<< values[i] << endl;
}
cout << "End of integer Stack Demo";
CString list[5];
char buf[80];
CStack names;
for( i = 0; i < 5; ++i )
{
cout << "\nEnter a name: ";
cin >> buf;
list[i] = buf;
names.push( list[i] );
}
for( i = 0; i < 5; ++i )
{
names.pop( list[i] );
cout << "Value at[ " << i << " ]= "
<< (const char *)list[i] << endl;
}
cout << "End of CString Stack Demo - Press RETURN: ";
cin >> ch;
return 0;
}
As with function templates, an explicit template class definition may be provided to override the automatic definition for a given type:
class CStack {...};
The symbol CStack must always be accompanied by a data type in angle brackets. It cannot appear alone, except in some cases in the original template definition.
Another method available for handling out of memory conditions and other exceptions appears only in the latest versions of C++. As of this writing only the Borland C++ version 4.xx compiler and the GNU C++ version 2.7.0 compiler implements the specifications of the ANSI/ISO C++ committee on exception handling. Exception handling involves three keywords in C++, throw, try , and catch. Throwing an exception lets you gather information at the throw point that could be used in troubleshooting the causes that led to the program failure. The throw keyword is analogous to using raise() with signal(). A C++ program can directly raise an exception in a try block by using the throw expression. The trying of code that may result in an exception is protected by having a catch routine. The catching of an exception allows the program to take actions that could led to a graceful program termination. Only synchronous exceptions are handled, meaning that the failure is generated from within the program, not from an external source, such an pressing CTRL-C or CTRL-BREAK. If asynchronous exceptions are to be handled then the signal() function must still be used along with, possibly, the raise() function.
Array::Array( int elements )
{
if( elements < 1 )
throw ( elements );
pArray = new int[elements];
if( pArray == (int *)NULL )
throw( "NO SPACE on the FREE store" );
}
void foo()
{
try
{
Array first( 10000 ), b( -5 );
....
}
catch( int x )
{
... // code to handle incorrect number of elements
... // in an Array type
}
catch( char *errMsg )
{
... // code to handle no more free store
}
}
The try-block specified by try must be followed immediately by the handler specified by catch. If an exception is thrown in the try- block, program control is transferred to the appropriate exception handler.
The throw keyword comes in two syntactic forms:
(1) throw
(2) throw expression
The second format, throw expression, will cause an exception to be raised. The innermost try block in which an exception is raised is used to select the catch **throw, causes the current exception to be rethrown. It is used when a second handler is needed to complete processing of an exception. With the second format, the expression thrown is a static, temporary item that persists until the catch handler is exited. The catch handler may use this expression in its processing.
void sample()
{
int x;
...
throw x;
}
main()
{
try
{
sample();
}
catch( int value )
{
...
}
}
The value thrown by throw in the sample() function persists until the handler with the signature catch( int value ) exits. The argument value is available for use within the catch routine as would any argument being passed to a function. When a function called from another function throws an exception, the process stack is unwound until an exception handler is found. This means that by exiting from the local function, any local automatic storage class variables will be destroyed.
void func2()
{
int local_2A, local_2B;
...
throw local_2A;
}
void func1()
{
int local_1A;
...
func2();
}
main()
{
try
{
func1(); // func2() is exited with local_2A and
// local_2B destroyed
}
catch( int value )
{
...
throw; // exception is re-thrown, possibly due to
// some condition within this catch() function
}
If the thrown expression was of integer type, the rethrown exception is of the same integer value and will be handled by the nearest handler suitable for that type, but not by the handler that re-threw the exception. Although C++ allows an exception to be of almost any type, it is useful to make exception classes. The exception object is treated exactly the way any object would be treated. An exception carries information from the point where the exception is caught.
enum ErrorType { BOUNDS, HEAP, OTHER };
class CArrayError
{
public:
CArrayError( ErrorType, int, int ); // for out of BOUNDS
CArrayError( ErrorType, int ); // for out of HEAP
CArrayError( ErrorType ); // for OTHER
...
private:
ErrorType _errType;
int _upperBound
, _index
, _size
;
};
Now a throw expression using an object of type CArrayError can be more informative to a handler than just throwing simple expressions.
...
throw CArrayError( BOUNDS, i, _upperBound );
...
The try keyword has the form
try
compound statement
handler list
The try block is where the decision is made as to what handler is called to handle a raised exception. The order in which handlers are defined determines the order in which the handlers with matching argument lists are tried. A throw expression matches the catch argument if it is
It is unwise to list handlers in an order that prevents them from being called. For example:
catch( void * ); // would also catch any "char *" arguments
catch( char * );
catch( BaseClass& ); // would also catch any "DerivedClass&" calls
catch( DerivedClass& );
try blocks can be nested. If no matching handler is available in the immediate try block, a handler is selected from its immediately surrounding try block. If no handler can be found that matches, then a default behavior is used.
The catch keyword has the following form
catch( formal argument )
compound statement
The catch appears to be a function declaration of one argument without a return type. catch routines do not accept more than one argument, because that would imply that more than one exception was being handled at once. The catch routine may have an argument list of ellipses, ..., which matches any argument. In addition, the formal argument can be an abstract declaration, which means it can have a type without a variable name. The catch handler is called by an appropriate throw expression. At that point the try block, which was in effect when the exception was thrown, is exited. Upon exit from the try block, the destructors for any objects that are local to the try block are invoked.
An exception specification can be part of the syntax of a function declaration
function_header throw( type list )
The type list is the list of types that a throw expression within the function can have. If no type list is specified, the compiler can assume that no throw will be executed by the function.
void func1() throw( int, CArrayError );
void func2( int x ) throw();
If an exception specification is left off, then the assumption is that an arbitrary exception can be thrown by the function. It is recommended that those exceptions that will be handled in a function be specified with the function declaration. Violations of the specifications are a run-time error.
When no other handler has been specified to deal with an exception, the system provides the terminate() handler as a default. Within the terminate() handler, the abort() function is called. The programmer can use the set_terminate() **abort(), by the default termination handler. When a function throws an exception that was not in its exception specification list, the system provides the handler unexpected() which will be called. By default the abort() function is called by the unexpected() handler. The programmer can use the set_unexpected() function to change the function called by the handler. The predefined exceptions in the C++ language are as follows:
Exception Type Header file
----------------------------------------------------------------
Bad_cast class typeinfo.h
Bad_typeid class typeinfo.h
set_new_handler function new.h
set_terminate function except.h
set_unexpected function except.h
terminate function except.h
Type_info class typeinfo.h
unexpected function except.h
xalloc class except.h
xmsg class except.h
In the following example, an allocation failure will result in the predefined exception xalloc being thrown. Your program should always be prepared to catch the xalloc exception before trying to access the new object. To handle the catching of an exception you must implement a try {} and catch {} pair of operations.
//
// LINES.CPP - dynamically allocate space from the free store
// using try and catch for exceptions. This will only work
// with the most recent BorlandC++ v4.xx or Microsoft Visual C++
// v2.x or Microsoft Visual C++ v4.0 compilers.
//
#include <iostream.h>
#include <except.h>
int main()
{
char **buf;
int height, width, i;
//
// acquire parameters concerning data to be input
//
cout << "Enter number of lines: ";
cin >> height;
cout << "Enter width of lines: " ;
cin >> width;
//
// allocate array of buffers for text
//
try // test for exceptions
{
buf = new char *[height];
for( i = 0; i < height; ++i )
buf[i] = new char[width];
}
catch( xalloc ) // enter this only if xalloc is
// thrown
{
cout << "ERROR: Could not allocate space."
<< endl;
return 1;
}
//
// get text from keyboard and save in array
//
for( i = 0; i < height; ++i )
{
cout << "Enter text: ";
cin >> buf[i];
}
//
// move down on the screen
//
cout << "\n\n\n\n\n";
//
// place text on the screen
//
for( i = 0; i < height; ++i )
cout << buf[i] << endl;
//
// return space to free store
//
for( i = 0; i < height; ++i )
delete buf[i];
delete buf;
return 0;
}