Saveen Reddy and G. Bowden Wise

Welcome to the inaugural edition of the ObjectiveViewPoint column! Here we will touch on many aspects of object-orientation. The word object has surfaced in more ways than you can count. There are OOPLs (Object-Oriented Programming Languages) and OODBs (Object-Oriented Databases), OOA (object-oriented analysis), and OOD (object-oriented design). We are sure you can come up with some OOisms of your own.

Our goal in this column is to explore object-orientation through practical object-oriented programming. This time, we look at C++, but in the future we will explore other areas of object-orientation. Learning an object-oriented language-a whole new way of programming-will pave the way for many exciting topics down the road.

Our intended audience consists of humble beginners to seasoned hackers. We assume that you have programmed in at least one procedural language, such as C or Pascal. Even if you are familiar with C++, please stay with us, you may learn some interesting new language features. Also, we will illustrate our points with many self-contained examples that you may later wish to incorporate into your own programs.

C++: A Historical Perspective

During the 1980s and into the 1990s, an explosive growth in object-oriented technology began with the introduction of the Smalltalk language. Object-Oriented Programming (OOP) began to replace the more traditional structured programming techniques. This explosion led to the development of languages which support programming with objects. Many new object-oriented programming languages appeared: Object-Pascal, Modula-2, Mesa, Cedar, Neon, Objective-C, LISP with the Common List Object System (CLOS), and, of course, C++. Although many of these languages appeared in the 1980s, many ideas of OOP were taken from Simula-67. Yes! OOP has been around since 1967.

C++ originated with Bjarne Stroustrop. In the simplest sense, if not the most accurate, we can consider it to be a better C. Although it is not an entirely new language, C++ represents a significant extension of C abilities. We might then consider C to be a subset of C++. C++ supports essentially every desirable behavior and most of the undesirable ones of its predecessor, but provides general language improvements as well as adding OOP capability. Note that using C++ does not imply that your are doing OOP. C++ does not force you to use its OOP features. You can simply create structured code that uses only C++'s non-OOP features.

C++: A Better C

Because C++ retains C as a subset, it gains many of the attractive features of the C language, such as efficiency, closeness to the machine, and a variety of built-in types. A number of new features were added to C++ to make the language even more robust, many of which are not used by novice programmers. By introducing these new features here, we hope that you will begin to use them in your own programs early on and gain their benefits. Some of the features we will look at are the role of constants, inline expansion, references, declaration statements, user defined types, overloading, and the free store.

Most of these features can be summarized by two important design goals: strong compiler type checking and a user-extensible language.

By enforcing stricter type-checking, the C++ compiler makes us acutely aware of data types in our expressions. Stronger type checking is provided through several mechanisms, including: function argument type checking, conversions, and a few other features we will examine below.

C++ also enables programmers to incorporate new types into the language, through the use of classes. A class is a user-defined type. The compiler can treat new types as if they are one of the built-in types. This is a very powerful feature. In addition, the class provides the mechanism for data abstraction and encapsulation, which are key to object-oriented programming. As we examine some of the new features of C++ we will see these two goals resurface again and again.

A NEW FORM FOR COMMENTS.

/* This is a traditional C comment */

// This is a C++ comment

THE CONST KEYWORD.

#define PI 3.14159265358979323846

const double PI = 3.14159265358979323846;

A very powerful use of const is found when it is combined with pointers. By declaring a ``pointer to const'', the pointer cannot be used to change the pointed-to object. As an example, consider:

int i = 10;
 const int *pi = &i;
 *pi = 15;
// Not allowed! pi is a const pointer!

Unfortunately, the user can still modify the data pointed at by the read-only pointer by using a type cast. This is called ``casting away the const-ness''. Using the above example, we can still change the value of i like this:

// Cast away the constness of the pi pointer and  modify i 

*((int*) pi) = 15;

There are two ways to add the const keyword to a pointer declaration. Above, when const comes before the * , what the pointer points to is constant. It is not possible to change the variable that is pointed to by the pointer. When when const comes after the *, like this:

int i = 10;
int j = 11;
int* const ptr = &i;
// Pointer initialized to point to i

ptr = &j;
// Not allowed, since the pointer is const!

*ptr = 15;
// This is ok, what is pointed at is not const

const int * const ptr = &i;

Remember that adding const to a declaration simply invokes extra compile time type checking; it does not cause the compiler to generate any extra code. Another advantage of using the const mechanism is that the C++ construct will be available to a symbolic debugger, while the preprocessing symbols generally are not.

INLINE EXPANSION

#define max (x, y) ((x)>(y)?(x):(y))

inline int max (int x, int y)
{
  return (x > y ? x : y);
}

When a similar function is needed for multiple types, the C++ template mechanism can be used.

Macro expansion can lead to notorious results when encountering an expression with side effects, such as

max (f(x), z++);

((f(x)) > (z++) ? (f(x) : (z++));

The variable z will be incremented once or twice, depending on the values of the x and y arguments to the function max(). Such errors are avoided when using the inline mechanism.

When defining a C++ class, the body of a class member function can also be specified. This code is also treated as inline code provided it does not contain any loops (e.g., while). For example:

class A {
  int a;
 
  public:
    A() { }
    // inline
    int Value()
    {
      return a;
    }
    // inline
}

Since the code for both the constructor A() and the member function Value() are specified as part of the class definition, the code between the braces will be expanded inline whenever these functions are invoked.

REFERENCES

int n = 10;

int& r= n;

r = - 10;

It is important to note that initialization and assignment are completely different for references. A reference must have an initializer. Initialization is an operator that operates only on the reference itself. The initialization

int& r = n;

r = -10;

C programmers know that C uses the call-by-value parameter mechanism. In order to enable functions to modify the values of their parameters, pointers to the parameters must be used as the ``value'', which is passed. For example, a routine Swap(), which swaps its parameters would be written like this in C:

void Swap (int* a, int* b) 
{
	int tmp;
	tmp = *a; 
	*a = *b;
	*b = tmp;
}

int x = 1;
int y = 2;
Swap (&x, &y);

Now consider the C++ version of Swap() which makes use of true call-by-reference.

void Swap (int& a, int& b) 
{ 
	int tmp;
	tmp = a;
	a = b;
	b = tmp;
}

int x = 1;
int y = 2;
Swap (x, y);

Another use for references is as return types. Consider this routine:

int& FindByIndex (int* theArray,int index) 
{ 
	return theArray[index];
}

FindByIndex(A, i) = 25;

Note that if FindByIndex() is made inline, the overhead due to the function call is eliminated. Inline functions that return references are attractive for the sake of efficiency.

DECLARATIONS AS STATEMENTS.

int IsMember (const int key)
{
	int found = 0;
	if (NotEmpty()) 
	{ 
		List* ptr = head;
		// Declaration 

		while (ptr && !found) 
		{ 
			int item = ptr->data;
			// Declaration 

			ptr = ptr->next;
			
			if (item == key) 
				found = 1;
		} 
	} 
	return found;
}

IMPROVED TYPE SYSTEM.

// Define some arrays of doubles 
double a[3] = { 11, 12, 13 }; 
double b[3] = { 21, 22, 23 };

// Initialize vectors from the
// double arrays 
Vector v1 = a; 
Vector v2 = b;

// Add the two matrices. 
Vector v3 = v1 + v2;

double norm = (double) v3;

OVERLOADING.

Suppose we need to search different types of arrays for a certain value. We can provide implementations for searching arrays of integers, floats, and doubles:

int Search (
	const int* data, 
	const int key);

int Search (
	const float* data, 
	const float key);

int Search (
	const double* data, 
	const double key);

Overloading is most often used for member functions and operators of classes. Most classes have overloaded constructors, for there is often more than one way to create a given object. All of the built-in types also have operators such as addition, subtraction, multiplication, and division. In fact, we can mix different types and still add them together:

int i = 1;
char c = 'a';
float f = -1.0;
double d = 100.0;
int result = i + c + f + d;

A FREE STORE IS PROVIDED.

For example, to allocate an integer:

int *pi;
pi = new int;
*pi = 1;

int *array = new int [10];
for (int i=0;i < 10; i++) 
	array[i] = i;

Suppose we have defined a type for complex numbers, called complex. We can dynamically allocate a complex number as follows:

complex* pc = new complex (1, 2);

All memory allocated using new should be deallocated using delete. However, delete takes on different forms depending on whether the variable being deleted is an array or a simple variable. For the complex number above, we simply call delete:

delete pc;

delete [] array;

Be careful, attempting to delete a pointer that has not been initialized by new results in undefined program behavior. However, it is safe to apply the delete operator to a null pointer.

New and delete are global C++ operators and can be redefined (e.g., if it is desirable to trap every memory allocation). This is useful in debugging, but is not recommended for general programming. More often, the operators new and delete are overridden by providing new and delete operators for a specific class.

When C++ allocates memory for a user-defined class, the new operator for that class is used if it exists, otherwise the global new is used. Most often, programmers define new for certain classes to achieve improved memory management (i.e., reference counting for a class).

The Class: Data Encapsulation, Data Hiding, and Objects

Vector v1(1,2), 
Vector v2(2,3), 
Vector vr;
vr = v1 + v2;

Vector v1, v2, vr;
add_vector( &vr , &v1, &v2 );

Though not illustrated in the above example, a class can limit the use of its data members and member functions by non-member code. This is encapsulation. If class K defines member M as private, then only members of class K can use M. Defining M as public means any other class or function can use M.

Let's take a look at a trivial implementation of Vector that will show is a little about constructors, operators, and references.

#include <iostream.h>
class Vector
{ 
 public: 
	Vector(double new_x=0.0,double new_y=0.0) 	{ 
		if ((x<100.0) && (y<100.0)) 
		{	
			x=new_x;
			y=new_y;
		} 
		else 
		{ 
			x=0;
			y=0;
		} 
	}
	Vector operator + 
		( const Vector & v) 
	{ 
		return
		(Vector (x + v.x, y + v.y));
	}
	void PrintOn (ostream& os) 
	{ 
		os << "[" 
			<< x 
			<< ", "
			<< y 
			<< "]";
	}
 
private: 
	double x, y;
};

int main()
{ 
	Vector v1, v2, v3(0.0,0.0);
	v1=Vector(1.1,2.2);
	v2=Vector(1.1,2.2);
	v3=v1+v2;
	cout << "v1 is ";
	v1.PrintOn (cout);
	cout << endl;
	cout << "v2 is ";
	v2.PrintOn (cout);
	cout << endl;
	cout << "v3 is ";
	v3.PrintOn (cout);
	cout << endl;
}

Vector v1;
InitVector( & v1, 99 , 99 );
v1.x = 1000;

We could have made `+' do multiplication instead. Though such manipulation is atypical, it can be quite useful. For example, C++ comes standard with a streams library which uses the << operator to provide output.

There is one useful thing about the addition operator: we don't have to pass the addresses of arguments. The arguments for the addition operator specify that the parameters are references (using the reference operator &-not the same as the address-of operator &). Recall that the reference operator allows us to use the same calling syntax as call-by-value and yet modify the value of an argument. The reference operator avoids the overhead of actually creating a new object. Thus, we can avoid a lot of indirection.

However, the most powerful OOP extension C++ provides is probably inheritance. Classes can inherit data and functions from other classes. For this purpose we can declare members in the base class as protected: not usable publicly but usable by derived classes.

In conclusion, we looked at some of the features that make C++ a better C. C++ provides stronger type checking by checking arguments to functions and reduces syntactic errors through the use of reference types. Programmers can also add new types to the language by defining classes. Although we have only taken a brief look at classes, we will see more abstract discussion of C++ object-orientation as well as general OOP concepts in upcoming columns.

Copyright 1994 by Saveen Reddy and Bowden Wise