Pointers and Dynamic Arrays

1. Outline of topics in the chapter

Pointer Variables

Basic Memory Management

Dynamic Variables and Automatic Variables

Uses for Pointers

10.2 Dynamic Arrays

Array Variables and Pointer Variables

Creating and Using Dynamic Arrays

Example: A Function that Returns an Array

Pointer Arithmetic

Multidimensional Dynamic Arrays

The -> Operator

The this pointer

Overloading the Assignment Operator

Example: A class for Partially Filled Arrays

Destructors

Copy Constructors

2. General remarks on the chapter

I strongly recommend that you obtain and use some version of the (free) Linux operating system or Windows NT, 2000 or XP. Some Linux distributions are Red Hat, Debian, Suse, and Mandrake. I use and recommend Debian because of the ease of upgrading from one release to the next. I have found Windows NT and 2000 stable enough for development of student programs. I have not used XP. However, I have been told by XP users that it is sufficiently stable for this use.

class A

public:

private:

};
A operator+(A& lhs, A& rhs)

{

int x;

return A();

}
int main()

{

A u, v, w;

return 0;

}
If your compiler requires the patch, the compiler will ignore the friend declaration. It complains about the access to private class data by the friend function operator+().
You must have a required Microsoft program, MDAC version 2.6 or later to successfully install the patch for all Visual Studio components. Version 2.5 will install the patches for VC++6.0. I do not know how to determine what version of MDAC is on a system other than downloading the patch and trying to install it.
I do know nothing about Macintosh systems or development environments, so I refrain from commenting on them.

10.1 Pointers

A pointer variable holds a pointer value. A pointer value is the address of a variable in memory. The C++ type system requires that there be a type for every object. Pointers and pointer variables are no exception. A pointer can point to an address, and the type object that a pointer is able to point at must be specified.

double *dPtr;

The strong typing of the C++ language requires that pointers declared to point to a particular type object be used only to point to that type object. An attempt to assign a variable of type pointer to int to a variable of type pointer to long will get a compiler error message to the effect that there has been an "assignment between incompatible pointer types." Each type object requires a pointer having type pointer-to-that-type. The type dPtr is "the type pointer to double" or, in C++ parlance, "dPtr is the type double*".
The text already warns of one of the pitfalls of pointer declarations:

int *x, y;

This is a declaration of x, with type pointer-to-int, and y, with type int. My students tend to have a problem declaring several pointers in one declaration. The problem is that the following appears to declare three pointer-to-int variables. Really, this declares only one pointer-to-int, and two int variables.
int* p1,p2,p3;// p1 is pointer-to-int; but p2,p3 are int.
The reason for this is that the pointer declarator, *, binds to the identifier. If the student will declare one variable per line, this problem does not occur. Of course, we could use a typedef. For example,

typedef int* intPtr;

intPtr p1, p2, p3; //p1 p2 and p3 all have type int*
Programming Language Notes (This material is not in the text.)

We mentioned overloading of operators in C++. The language overloads the operators for us with regard to the primitive types. For example, + is able to add any of char, short, int, long, float, double, or long double. Most languages have operator overloading at this level. This operator overloading is carried out by the compiler, just as operator overloading is done by the programmer. The compiler recognizes the type of the operands of the + operator (or whatever operator we are discussing) then generates the appropriate machine instructions to carry out the operation. The machine instruction is usually different for each primitive type.

If used in the declaration,

int * iPtr;

the * is called a "pointer declarator" by language lawyers. This statement declares iPtr as a "pointer to int". Read it in reverse: iPtr is a pointer (*) to an int. This works on all but the most complex declarations.

*iPtr = 7;

we are using the * as the indirection operator or dereferencing operator. This statement says, store 7 where the pointer, iPtr, points.
We haven't said where iPtr points. We should have. Let's do it:

int x = 49;

iPtr = &x;

The & in front of the x is called the "address of operator". It takes the address of x. The assignment makes iPtr point at (have the value of the address of) the int variable x. (The & is another operator overloading. If it is used between the type and the formal parameter in a function declaration (prototype), language lawyers call this a "reference declarator" and it means in that context, "this is a reference parameter." If it is used in an expression where it has two arguments, it is the bitwise AND operator.⁵

Now let us execute the above assignment to the dereferenced pointer:

*iPtr = 7;

int *p;

int y = -15;

int *int_ptr1 = x;

int *int_ptr2 = y;

int_ptr1 = int_ptr2; //Pointer assignment. This makes

//int_ptr1 point at the same place

//int_ptr2 points.

*int_ptr1 = *int_ptr2; // Dereferenced pointer

//assignment. This assigns the

//values stored where the pointers

//point.

The most important uses of pointers is the case where pointers point to variables that have no name. The operator new is used to create variables that have no identifiers to serve as their names.