[Phy 405/905 Home Page] [ Lecturer ]

3. Pointers - Part 5

We end our endless discussion of pointers by covering multi-dimensional arrays and pointers, and showing how objects are dynamically created in C++ (both single objects and arrays of objects).

Multi-dimensional arrays and pointers

So far we have been considering only 1-dimensional arrays, that is, arrays declared and used as in:

int q[5] = {1,4,5,1,4};
q[1] = q[2];

int r[5][3];
r[0][0] = 1; // assign to "first" element of r
r[4][2] = 1; // assign to "last" element of r

int q[5][5][100];
for (int i=0; i < 5; ++i) // set all elements of q == 3
	for (int j=0; j < 5; ++j)
		for (int k=0; k < 100; ++k)
			q[i][j][k] = 3;

double f[4,3]; // ***illegal***
double g[4][3]; // legal

Initialization of multi-dim arrays

int r[3][2] = {}; // r filled with 0's
int q[2][3] = { {1,2,3},{4,5,6} };

int q[2][3] = { {1}, {2} }; // same as q[2][3]={ {1,0,0},{2,0,0} };

int q[4][3] = { 1,2,{3},{4,5,6}]; // same initializer as  
                                  // {{1,0,0},{2,0,0},{3,0,0},{4,5,6} }

sizeof() and multi-dimensional arrays

int q[4][3];
cout << "# of elements in q = " << sizeof(q)/sizeof(int);

Mult-dim arrays and pointers

Row-ordered vs. column-ordered

int q[3][2] = { {1,1},{2,2},{3,3} };

To understand what this means, define the first index of a multi-dimensional array to be a "row", with the last index signifying a "column" index. For a two-dimensional array, this corresponds to thinking of the array as a matrix, with the first index running over rows, the second over columns:

int q[3][2];
for (int i=0; i < 3; ++i) // iterate over each row
	for (int j=0; j < 2; ++j) // iterate over each column
		cout <<q[i][j];

Row-ordering means that stepping through the elements of a single row corresponds to a walk through consecutive memory locations, while index-ordering means the reverse (all the elements of a column are contiguous in memory):

int q[3][2] = { {1},{2},{3} };
int *r = &q[0][0]; // pointer to run through q[][] element-by-elememt
int *s = r + sizeof(q)/sizeof(int); // just past end of q[][]
for ( ; r < s; ++r)
	cout << *r << ' ';

1 0 2 0 3 0 

Array name conversion to pointer

double q[20];
double *r = q; // q not accessed by its one index, is converted

int q[i][j] ... [k]; // ***note*** the "..." indicates omitted indices

int q[3][2] = { 1,0,2,0,{3,3}};
int (*r)[2] = q; // q implicitly-converted to pointer to an int[2]
cout << *r[0] << ' ' << *r[1]; // r is the pointer to an int[2], 
                               // *r "is" an int[2]
                               // outputs "1 0"

int *s = q[0]; // q declared above, q[0] is type int[2] --> int*
*s++ = 4; // just changed q[0][0]
*s++ = 5; // just changed q[0][1]

q; // expression of type int *[2], points first element of first row of q
q[1]; // type int[2], can be implicitly converted to int*
q[1][1]; // type int

cout <<sizeof(q)/sizeof(int)       << ' ';
cout <<sizeof(q[0])/sizeof(int)    <<' ';
cout <<sizeof(q[0][0])/sizeof(int) <<'\n';

6 2 1

pointer arithmetic

For example, if you need to initialize all elements of a multi-dimensional array to a value, but don't care about the actual order, you can do the following:

int q[5][5][5] = {}; // q initialized to zero
// initialize entire array to 100
int *r = &q[0][0][0];
int *s = r + sizeof(q)/sizeof(int);
while (r < s)
	*r++ = 100;

int (*t)[5][5]= q;
for (int i=0; i < 5; ++i)
		*(int *)(t++) = 99; // sets q[0 to 4][0][0] = 99

typedef int FiveByFive[5][5]; 
typedef FiveByFive *FiveFivePtr;
FiveFivePtr t = q, u = q+5;
while (t < u)
	*(int *)(t++) = 99;

If all else fails, you can always rely on simple int* and do the pointer arithmetic yourself:

int *t = &q[0][0][0];
int *u = t+sizeof(q)/sizeof(int);
const int offset = sizeof(q[0])/sizeof(int);
for  ( ; t < u; t += offset)
	*t = 99;

&q[0][0][0]+i * 25 + j * 5 + k

Pointer arrays, argc and argv, and command-line arguments

For example:

int q[10][20];
q[4][5] = 8;

*( *(q+4) + 5) = 8;

The innermost dereferenced pointer expression, (q+4), is of type int*[20], that is, is a pointer to an array, or a pointer to a pointer. For that matter, (q+1) is a pointer to a pointer, as is (q+2), and so on, so the following is legal:

**q = 8; // set q[0][0] equal to 8

int *r[10];

for (int i=0; i < 10; ++i)
	r[i] = q[i];
q[2][0] = 4; // sets q[2][0]==4
r[2][0] = 4; // sets r[2][0]==4

Pointer arrays are used for more than just "copies" of multi-dimensional arrays - they're used to implement arrays with non-constant stride, i.e. , the size of the row is allowed to vary. The most basic example is for arrays of strings, which are used for handling command-line arguments.

Recall that in UNIX (and VMS, if things are set up properly, see Lecture 0, on "C++ compilation basics)"), when a C++ program is run, command-line arguments can be passed. Assuming you have compiled and linked a program named my_prog,you can run the program with the command:

my_prog 23    Hi     lastone

#include <iostream.h>
int main(int argc, char *argv[])
{
	cout << "# of arguments is "<< argc-1 <<'\n';
	cout << "program name is "<< argv[0] <<'\n';
	cout << "first letter of prog name is '"<<argv[0][0]<<"'\n";
	char **argv_copy = argv;

	while (argc--)
		cout << *++argv<<'\n';

	cout << "print arguments again:\n";
	while (++argv_copy)
		cout << *argv_copy <<'\n';		
}

• the number of arguments (+1) is given by argc, so argc >= 1
• the arguments, in string form, are contained in argv[1... argc-1]. argv[argc] is guaranteed to contain the null (char) pointer
• the program name is contained in argv[0]
• though argv was accessed to get the first character of the program name (by "argv[0][0]"), argv is not a two-dimensional array; argv could not have been defined in a statement like char not_argv[i_max][j_max], which is seen by considering the following points:
  • it is not necessarily true that the string pointed to by argv[1] is immediately followed in memory by the string pointed to by argv[2], which on the other hand is true for not_argv[][]
  • the strings pointed to by argv[1], argv[2], ... are not usually of the same size. They are not of a definite length j_max as is true for not_argv[][]
  • argv is assigned to argv_copy, which is a variable of type char**. The variable not_argv[][] only be assigned without explicit cast into a variable of type char *[j_max].

char str1[] = "hi";
char str2[] = "there";
char *good_array[] = {str1,str2};
char *dangerous_array[4] =
{ "hi", "there", "last   string", "true last string"};

cout << (sizeof(good_array[0])==sizeof(char *)) << '\n'; // outputs '1'
cout << (sizeof(good_array[0])==sizeof(str1))   << '\n'; //outputs '0'

... and functions

void f(int *q);
void g(int q[]); // f() and g() take exactly the same argument!
int r[20];
f(r); // legal
f(r+1); // also legal

const int max_str = 4, max_buf=512;
int my_buf[max_str][max_buf];
void q(char strlist[max_str][max_buf]);
void r(char strlist[][max_buf]);
void s(char (*strlist)[max_buf]);
// function call
q(my_buf);

In the same way, th ese declarations of main() are equivalent:

int main(int argc, char *argv[]);
int main(int argc, char **argv);

Dynamic allocation and creation

Pointer arrays and dynamically-created objects

Motivation

int main(int argc, char *argv[]);

Consider the alternative, if argv[] had been defined and declared as a true two-dimensional character array,

int main(int argc, char argv[][max_arg_length]);

An example of pointer arrays (implementing argc, argv[])

#include <ctype.h> // for isspace()
#include <iostream.h>

const int max_args = 2000; // arbitrary limitation that could be
                               // removed using new[](), see below
char *argv[max_args+1]; // holds pointer to each argument, last is null 
int argc;               // number of arguments found
void read_command_line(); // used to replace standard argc, argv[]

int main() // simple version of main(), no command-line handling provided
{
    // read in command line, then print out arguments
    read_command_line();     
    for (int i=0; i < argc; ++i)
        cout << "argv["<<i<<"]: '"<<argv[i]<<"'\n";
        
    return 0;
}

void read_command_line()
{
    const int line_buffer_size = 5000;
    static char command_line[line_buffer_size]; // why is this static?
    
    cin.getline(command_line,line_buffer_size);
    
    char *p;
    for ( argc = 0, p=command_line; *p && argc < max_args; )
    {
        while (isspace(*p)) // find start of arg or end of command_line
            ++p;    
        argv[argc++] = p; //  arg begins here
        while (!isspace(*p) && *p) // find end of arg or command_line
            ++p;    
        if (*p)     //  null-terminate this arg if not end of command_line
        {
            *p++ = '\0'; 
            while (isspace(*p)) // find beginning of next argument
                ++p;
        }
    }    
    argv[argc] = 0; // set last argument pointer to null
}

• why is command_line[] made a static class object?
• the function isspace(), declared in <ctype.h>, returns non-zero if the character passed to it is space, formfeed, newline, carriage return, tab, or vertical tab, and zero otherwise - it tells you whether the character is whitespace or not. There are other related functions available: isdigit(), islower(), isupper(), and so on.
• the getline() function reads a line of characters and saves it in the buffer provided, taking care not to read more characters than the actual length of the buffer (given in the 2nd argument to getline()). The string is null-terminated in the buffer
• there are still "significant" limitations of this code: the maximum length of an argument is fixed at the buffer size (line_buffer_size-1), and the number of arguments is limited by the (compile-time determined) size of argv (max_args is the max number of arguments permitted).

char *argv[max_args];

new and delete operators

Creating objects with new()

• create a single object (allocate memory, and possibly initialize the new object)
• returns a pointer to the memory containing the new object, if successful
• returns null otherwise (if the new operator returns)

int *r[20]; // pointer array
for (int i=0; i < 20; ++i)
	if ( !(r[i]=new int) ) // catch new() failure
	{
		// ***warning*** this is not fail-safe! see below
		cerr << "acckk --- allocation failed on i="<<i<<"\n";
		exit(1);
	}
*r[0] = 4; // access newly allocated memory

On the other hand, according to the latest publicly-available draft of the C++ standard (April 1995), the default behavior of the new operator upon allocation failure is to pass control to the "exception" handler, which again by default ends program execution. So the new operator would never return in this case (let alone return a null pointer), and the code following the if() would never be executed. In fact, the precise behavior is highly customizable, and I'll outline one simple way of dealing with allocation errors in the section below on error-handling for the new operator. For the moment, assume that new operator failure is dealt with one way or another, so the examples below will omit a check for a null return.

The new operator only works for objects - functions cannot be defined in this way. The objects created by the new operator (and pointed to by the return value of the new operator) continue to exist and occupy memory until they are destroyed using the delete operator (see below). This means that the following example:

while (1) // infinite loop
{
	// q is local scope, is initialized on each iteration of this loop
	// and memory is allocated (and never released) on *each* iteration
	int *q = new int;
}

It should be noted that parentheses are not allowed in the type name following new; there is, however, a second form of the new operator, where the type name is enclose in parentheses. You can use it for more complicated declarations or just to make things more obvious:

int  (**r)[5] = new  int (*)[5];  // illegal - parsed as (new int) (*)[5]
int  (**s)[5] = new (int (*)[5]); // ok - allocates a ptr to 
                                  // array of 5 ints

Initialization using new()

double *x = new double; // no initialization
double *y = new double(4.3); //initialization to 4.3
double *z = new double(); // initialization to 0.0

Incidentally, the last form is an explicit call to what we would be called the "default constructor" for objects of type double.

Destroying objects with delete()

int *x = new int;
// use variable x ....

// now we're done with it:
delete x; // deallocates memory that used to be associated with x

double *x = new double(4.0);
delete x;
*x = 4; // ***error!! **** x referred to after deletion, unknown results!
delete x; // *** error **** deleted an object twice!

double *x = new double(4.0);
delete x;
x = 0;
delete x; / okay

For fundamental types (int, double,...), there is not usually much point in using the new operator to create/allocate single objects, as opposed to (for example) just using a static storage class variable. If you might need a float but aren't sure -why not live it up and define one? If you don't end up using it, it's not likely to be a big deal.

There's also storage overhead to consider -because of something called alignment requirements, the details of which are machine dependent but the existence of which is universal, "small objects" like char can be located at any address in memory, but "large objects" like long double might be required to fall on even addresses, or multiples of 4 bytes, or .... The main point is that because of the new operator has to work properly for general types, if asked to create a char, it will do so under the most restrictive requirements, e.g., that the address is a multiple of 4. A single-byte object (a char) will then take up 4 bytes, which is certainly wasteful, but the price of generality.

The new operator for single objects really comes into its own for more complicated objects, of types defined by the users (classes). The other importance of the new operator is for several objects at a time, i.e., creating arrays.

Creation with new[]()

// integer array
int *j = new int[20]; // j points to allocated array

// create a copy of a character array
char str1[] = "hi there";
char *q = new int[ strlen(str1)+1 ]; // strlen() (from <string.h>) doesn't 
                                     // include final null character
strcpy(q,str1); // copy str1 TO q (strcpy() declared in <string.h>)

char **my_argv = new char[20][30];       // incorrect type!!
char (* my_argv)[30] = new char[20][30]; // okay!

• the first dimension can be an arbitrary numerical expression, but negative values will produce undefined results. The first dimension can be 0 (which I think is reasonably allowed for generality), in which case the new object will still take up space (but contain no array elements):

int i = 20; // non-const integer
char s[i];  // ***illegal*** array size must be CONSTANT integer
char *t = new char[i]; // okay!!!

• the subsequent dimensions must be positive constant integral expressions. Note that because of the limitations of array types (which involve constant sizes for the 2nd and subsequent dimensions), I can't even write a bad example without a cast:

int i=20, j=30;
char *q = (char *) new q[i][j]; // illegal!! j is not const
// an attempt without a cast:
char (*r)[j] = new q[i][j]; // illegal, but left-hand-side is also illegal
                            // because j is not const

Another alternative is to use pointer arrays:

int num_elem = 10; 
int num_rows = 5;  // non-const, but THAT's OKAY!
char **q = new char*[num_rows]; // note:
                                // q cannot be type char (*)[num_elem]
                                // (num_elem is non-const) 
                                // so q must be char **
for (int i=0; i < num_elem; ++i)
	q[i] = new char[num_elem];

This, incidentally, is how we could have created an command-line reading routine that allowed for arbitrary number of arguments and arbitrary argument length.

I haven't discussed initialization for new[] because there isn't any - sorry. If you think about it, how would you specify the initializer for an array whose size is defined at run-time? Of course, you can always explicitly assign values as desired into the array, once you've created it.

Finally, the storage efficiency of arrays of small objects (using new[]) is likely to be better than that for single objects (using new). The reason is that alignment restrictions apply to padding applied to the end end of the array - a statement like:

new char* q = new char[18];

Destruction with delete[]()

int *j = new char[20]; // new returns char*, but remember to call delete[]
delete[] j;
int *k = new char[20];
delete k; // **** oops!! ***** should have called delete[]

char *q = new char[20];
char *r = new char;
delete[] q; // okay
delete[] r; // ***** bad ***** should have been delete r, no []'s

This poses a problem for new[] (and delete[]): how will delete[] know how much memory the object took up (how many elements)? Clearly, the new[] operator will have to store the number of elements somewhere. At the end of the array clearly will not work (if we knew where the end was, we wouldn't have this problem), so in fact it stores the array size just before the array in memory. When delete[] is called, it looks at the number stored just before the supplied pointer. In the example above, the number right before q is 20, whereas the "number" right before r will have some fairly random number (since r was the result of new and not new[]). Chaos will ensue when delete[] destroys r. And rather than incur a further storage overhead by also requiring new to store a '1' before each single object allocated, C++ instead demands that you keep things straight and use delete[] for objects created with new[], and delete for objects created with new.

Note that a pointer to the beginning of the array will serve just as well for the call to delete[], because the only two things needed are the type and number of elements:

int *r = (int *)(new int[20][20][20]);
delete[] r; // okay, deletes all the elements of the matrix pointed to

delete[]  (r+1);

A last thing to watch for is that in the pointer array example above, each element of q has to be deleted, as well as q itself:

// delete q and the objects it points to
for (int i=0; i < num_elem; ++i)
	delete[] q[i];
delete[]q;

new operator and error-handling

As I said before, in more current C++ compilers, a failure in the new operator will not result in the new operator returning null, because by default the new operator will never return. But in older compilers (like the current DEC compiler) the following will be problematic:

const long int huge = 0xffffffffff; // assume this is too big
char *q = new char[huge];
q[0] = 'a'; // ***** bad, if q is the null pointer

#include <stdlib.h> // declares exit()
#include <new.h>    // declares set_new_handler()

void new_error() // function called when new fails
{
	cerr << "new or new[] failed to allocate\n";
	exit(1);

int main()
{
	set_new_handler(&new_error);
	const long unsigned int i = 0xfffffffffffff;
    char* x= new char[i];
 	x[0] = 'a'; // guaranteed that x is non-null

	// done with x, delete it
	delete[] x;

	return 0;
}

• using a "current" compiler, the program quits, signalling a bad allocation exception
• using an "old" compiler (the current DEC compiler), the program does not quit; instead, the new operator returns a null pointer

This is the lecture that never ends,

it just goes on and on my friends...

I just went and - started writing it, not knowing what it was

and I'll continue writing it forever just because...

[ Phy 405/905 Home Page] [Lecturer ]