Now that you have learned what an array is, it should be clear that just as you can make an array of int's or float's, you can also make an array of char's. The special thing about an array of char's though, is that an array of char's is capable of storing words or sentences. If you make an array of characters and then put a NULL at the end, you have created a special array called a string.

A string is a NULL terminated array of chars^*.

cin and cout are built to work with strings. That means that if you give, for example, cout the name of a NULL terminated char array, it will print out the entire array until the NULL is reached. If, however, you supply cout with a regular char array (i.e. one which is not NULL terminated) it will print beyond the end of the array. It will continue printing the junk in memory after the array until it reaches a NULL somewhere in that junk. Make sure to only give cout or cin a single character or correctly formed string.

Strings are not so hard to create. Any set of character literals inside quotation marks is automatically followed by a NULL, so it is a string. It can be assigned to an array of chars and then that array will be a string. Let's see an example of the power of cin and cout with strings.

int main()
{

char ar[60]="greg";
cout<<ar;
//// ar="hheeee"; //illegal
cin >>ar;
cout<<ar;

return 1;
}

Then I assign the array the literal string "greg". (This can ONLY be done when the array is declared, not afterward.) The first four spaces of the string contain the letters greg and the fifth space contains a NULL character. The remaining 55 characters in the array are not used and therefore contain unknown or junk data.

Then I overwrite the array with whatever the user types in. (Note: If he types more than 59 character I will over-run my array.)

Then I can print out the new contents of the array. Notice how cin and cout are smart enough to print the entire array when I give them the name of the array. This will not work with an int or float array. It only works with a NULL terminated character array. This is because the cin and cout functions know to read until they reach a NULL. Since int, float, short, etc. arrays are not necessarily NULL terminated, cin and cout have no way to know when the end is reached. Therefore they cannot print regular arrays. However, they can of course print the individual elements of an array.

Ok, now we have a string. But since the string is actually just an array of characters I can mess around with it. For example, I can print the array in backward order. First, I will show you how to print it in forward order. (This is actually what the function cout does when you give it an array name, but we will print each element ourselves manually instead of using cout's built-in capabilities.)

int printString( char myString[] )
{
int i;
for ( i = 0; myString[i] != NULL; i++)
  { cout << myString[i];
  }
return 1;
}

This function starts at the beginning of the array it is passed and keeps printing out the letters one at a time until it reaches the end of the array. ( Remember string arrays always end with a NULL, so the NULL will be my clue to know when the array is over.)

To print the array backward I first have to find the end of the array. So I will count till I get the end of the array and then work backward. Let's see the example:

int reversePrintString( char myString[] )
{
int i;
for ( i = 0; myString[i] != NULL; i++);
for ( ; i >= 0; --i)
  { cout << myString[i];
  }
return 1;
}

I can also do other things, like, for example, find the first 'p' in the string. Or for example, change the original string by, say, taking any lowercase t's in the array and making them into capital T's. Let's see this second example.

int t_to_T( char myString[] )
{
for (int i = 0; myString[i] != NULL; i++)
  {
    if (myString[i]=='t')
        {
        myString[i]='T';
        }
  }
return 1;
}

As we explained in the section on arrays, the changes made here will affect the original array in the calling function. And notice, I did not print out the string in the function. I simply changed the string. If I would want to print out the array I would do that in the calling function, the main() function for example:

int main()
{
char charlie[100]="this is a test string.";
t_to_T( charlie);
cout << charlie;
return 1;
}

Notice that when I called t_to_T I passed the name of my string, charlie. I did not have to use and should not use the [ ] 's . Also notice that the string is much larger than it needs to be. This is ok, but I have wasted some 75 char's.

String Functions

In the string.h library there are various ready made functions for you to use:

• int strlen (const char * str);// returns number of characters in str
• char * strcpy (char * str1, const char * str2);// copies str2 into str1
• char * strcat (char * str1, const char * str2);// copies str2 to the end of str1, concatenation
• int strcmp (const char * str1, const char * str2);// if str1 is less than str2 returns an integer less than 0, if str1 is equal to str2, returns 0, if str1 is greater than str2 returns an integer greater than 0

• int strnlen (const char * str, int n);// returns number of characters in str, but not more that n
• char * strncpy (char * str1, const char * str2, int n);// copies not more than n characters of str2 into str1
• char * strncat (char * str1, const char * str2, int n);// copies not more than n characters of str2 to the end of str1, concatenation
• int strncmp (const char * str1, const char * str2, int n);// compares at most n characters of str1 and str2, if str1 is less than str2 returns an integer less than 0, if str1 is equal to str2, returns 0, if str1 is greater than str2 returns an integer greater than 0

Array Copying

We know that the assignment operator ( = ) will copy the value of one data-type into a variable. For example I can write:
short p = 90; But the assignment operator will not copy an entire array. The following example will not compile because I am trying to copy a whole array into another array:

int main()
{
short lucy[10]={34,5,34,64,36,2,634,8,17,20};
short linus[10];
linus=lucy;
return 1;
}

int main()
{
short i;
short lucy[10]={34,5,34,64,36,2,634,8,17,20};
short linus[10];
for( i=0;i<10;i++)
   linus[i]=lucy[i];
return 1;
}

void shortArrayCopy( short ar1[], short ar2[], short size )
{
short i;
for ( i = 0; i < size; i++)
  {
    ar2[i]=ar1[i];
  }
return ;
}

Here is a string copy function:

void stringCopy( char str1[] , char str2[])
{
int i;
for (i = 0; str1[i] != NULL; i++)
  {
    str2[i]=str1[i];
  }
str2[i]=NULL;
return;
}

Remember that you cannot use the = operator to copy an entire array whether it be a float array or even a string.

Pointers

If I write:

int a = 70;
cout<< &a;

In the above example I merely printed that weird number. What if I wanted to store it in a variable. What type would that variable be? I can't use a simple int since this number is not really a regular int. It is the address of an int. It is a new type, an address of an int type. To declare a variable of this type we write:

int *p;

float *ppp;

To store the address of "a" in "p" and then print it, I would write the following:

int a = 70;
int *p;
p = &a;
cout << p;

In the above example "p" is called a pointer because while it is not "a" it does point to the location of "a" in memory. Any variable we declare with a star * is a pointer to the type of variable declared. Thus, "ppp" is a float pointer. This is just a short hand way to say that "ppp" is a type capable of containing the address of a float. Now we will see that we can access a variable by means of its address. This is called dereferencing the pointer. This does not seem very useful at the moment, but it is very useful and we will see why.

Dereferencing

Let's say I have the address of a certain space in memory, how can I access or change its contents? For example, can I change "a" by means of "p"? The answers is yes, but I need to use a special operator, the asterisk *. (Yes, this is the same * we use in a pointer declaration, so it can be confusing. But this operator is only used not in a declaration.) By placing a star before "p" I indicate that I am refering to the content that the memory space "p" points to. In short hand this is called dereferencing "p". Here is an example which changes "a" from 70 to 90 by means of dereferencing "p":

int a = 70;
int *p;
p = &a;
*p = 90;
cout << a;

The " *p = 90; " in the above example means go to the place to which "p" points and go to the contents of that place and assign it the value 90. Since "p" points to the location of "a" , the contents of that location is "a". So "a" will be assigned the value 90. The use of the asterisk * to dereference a pointer should not be confused with its use in declaring a pointer. These two operations have nothing in common except their use of the asterisk symbol. This often confuses students. It would have been clearer if the inventors of C++ had used two different symbols for these two different operations, but they didn't.

If you ever by mistake tried to print an array of int's all at once using cout like this

int a[] = {1,2,3,4,5,6,7,8,9,10};
cout << a;

int a[]={34,14,25,3,64,29,45};
int i, *p;
p = a;
for(i=0; i < 7; i++)
    cout << p[i];

You may ask yourself is there a data-type capable of storing the address in memory of "p" in the above example? In the above example, "p" is a pointer to an int. What type can store the address of this type? A regular int pointer (int *) won't do the trick. You will need to use a type designed to store an address of an address. This is known as a double pointer because it points to a pointer. You declare something of this type like this:
int ** pptr;
Now "pptr" can store the address of "p" like this:
pptr = &p;
You may guess correctly that this process can go on and on. We can have a pointer to a double pointer. And so on. But generally we will never need much more than a double pointer. Later we will see a practical use of double pointers.

Pointer As Function Parameters

Pointer Arithmatic

int myArray[3];
*myArray =8;

int myArray[3];
*(myArray+1) =8;

Dynamic Allocation of Memory

float farray[100];

short size;
cin >> size;
float farray[size];

short * arrayPtr, size;
cin >> size;
arrayPtr = new short[size];

arrayPtr[0] = 340;

The new command can also be used to create a single variable at run time. Here is how to use new to create one variable:

float *ptr;
ptr=new float;
*ptr=3.1415;

I can also supply the new float (or what ever data type I create) with a value at creation time. I do this like this:

float *ptr;
ptr=new float(3.1415);

Since "ptr" is a variable like any variable it can be used to point at one thing and then at another thing and so on. It is re-usable. So, for example, I can write the following:

float *ptr;
ptr=new float(3.1415);
ptr=new float(200.5);

float *ptr;
ptr=new float(3.1415);
delete ptr; ptr=new float(200.5);

Arrays created with the new command must also be deleted. In short, any time you create memory blocks with the new command, you must free them again with the delete command. Here is an example of creating and freeing an array dynamically:

int * arrayPtr;
int size;
cin >> size;
arrayPtr = new int[size];
delete [] arrayPtr;
arrayPtr = new int[size+10];
delete [] arrayPtr;

Multi-dimensional Arrays

So far we have had examples of array which are sets of variables. In these examples there has been one index for each element. If we would represent these arrays graphically they could be drawn as a row of numbers in boxes, like this:

index 0 1 2 3 4 5 6 7 8 9

values 20 17 2 34 61 2 75 93 32 8

For example, a two dimensional array could be declared in the following way:

int myArray[10][3];

When arrays are created, their elements are not assigned any initial values. Therefore we can't know what is in each cell of the array. It will likely be zero, but we can't be sure. We will call this content junk since it is meaningless data. I indicate this junk with the question mark. The above array could be drawn like this:

index 0 1 2 3 4 5 6 7 8 9

0 1 2 ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?

We access elements of two dimensional arrays by using 2 indexes. For example, if we wanted to assign the value 18 to the element at position 4 down and 2 across in the above array we would write something like this (remember, indexes start with 0 so the 4th row is index number 3):

myArray [3][1] = 18;

This would change the array in the following way:

Essentially, we now have a set of 30 integers which we can access (change or printed etc.) by using two sets of indices. The name of the array ( myArray ) refers to this whole set of integers.

We can also make arrays of 3 or 4 dimensions though these are impossible to draw in two dimensions, and they are bit harder to imagine in your mind. To think of a 3 dimensional array imagine a 2 dimensional array and then think of each cell in that array itself containing many elements. A three dimensional array is created in the following way:

int myArray[10][10][3];

This will create an array named myArray containing 300 integers. We can access any element of this array by using 3 indices. For example, if we wanted to assign the value 312 to the element at position 3 down and 7 across and 2 in, we would write something like this

myArray [2][6][1] = 312;

Once you grasp this you might be then able to think one more step. Imagine each element of your 3 dimensional array as containing not just one element, but a whole set of elements. It is quite hard to imagine anything more than 3 dimensions, but theoretically, you can have 4, 5, 6, 7, etc. dimensional arrays. In practice you should never use more than a 3 dimensional array for three reasons: (1) They will use up a lot of memory even with relatively small indexed ( an even sided 4 dimension array of size 100 integers will have 100,000,000 integers in it, or 400 mb of data ) (2) You will make errors (3) You will confuse anyone trying to read your code. Even using 3 dimensional arrays is not really advisable.

Dynamic Allocation of 2 Dimensional Arrays

We have seen that we can allocate a one dimensional array dynamically by using the new command. The same is true for a two or three dimensional array. But it is more complicated. First we have to think how a two dimensional array will be stored in memory. It is stored as a set of one dimensional array. Since each of these one dimensional arrays has one pointer to it, we need to create a set of pointers. This is done by creating an array of pointers. Here is how to create an array of 10 int pointers:

int *ptrArray[10];

Then we need to make each of these pointers point to a new array. To do this, we simply loop through all the pointers and assign each one a new array. Here is an example of creating 10 int arrays of 100 ints each and using our array of pointers to point to them:
int *ptrArray[10], i;
for(i=0;i < 10; i++)
    ptrArray[ i ] = new int [100];

I could then assign values to the array by using the normal method of dereferencing a 2 dimensional array. Here is how to assign values to this new 2-D array:
ptrArray[0][0]=130;
ptrArray[0][1]=108;
ptrArray[9][87]=24530;

And so on...

I can also use variable to create this 2-D array. Thus I can have the user enter the array size. To do this I need to have a pointer to my array of pointers. For this I will need to use one of those double pointers we discussed above. I need a double pointer because the name of my array of pointers points to the first element in that array. Since that element is a pointer (just like all the elements in that array) the thing that points to it must be a pointer to a pointer, or in other words a double pointer. Here is an example of creating a fully dynamic 2-D array where the user decides its size:
int **ptrArray, height, length, i;
cout << "Length? ";
cin >> length;
cout << "Height? ";
cin >> height;
ptrArray= new int* [height];
for(i=0;i < height; i++)
    ptrArray[ i ] = new int [length];

To free this memory when I am done with it, I will need to loop just as I did when I created the array. Here is how this is done:
for(i=0;i < height; i++)
    delete [] ptrArray[ i ];
delete [][] ptrArray;

Notice that I also freed the double pointer. I did this by using delete followed by two sets of []'s. This indicates that the double pointer ptrArray should be deleted.

Reference Parameters

^*Note: There are other types of strings like the class String and strings where the first element contains the value of the length of the string, but for the purposes of this chapter, this is the relevant definition.

Function Pointers

Just as we have said that the name of an array is a pointer to the first element in the array so too, a function name is pointer to the beginning of the code where the function is stored in memory. Therefore, I can pass a function as a parameter to another function. In the following example doOtherFunct is a function whose sole ability is to run another function. It can run any function that it is passed so long as that function returns an integer and accepts as parameters two integers.

int doOtherFunct( int param1, int param2, int(*otherFunct)(int, int))  //line 1
{
int p = (*otherFunct)(param1, param2);                                      //line 3
return p;                                                                   //line 4
}

Exercises

1. Write a function which is passed two float arrays and their size. It should copy the contents of array1 into array2. Call the function floatCopy.
2. Write a function which is passed two strings. It should copy string1 into string2, but in reverse order.
3. Write a function which is passed one string and one char. It should return a pointer to the first occurrence of that character in the string.
4. Write a function to compare two strings. Return a positive value integer if the first string alphabetically precedes the second. Return a negative value if string two precedes string one and return 0 if they are identical. Do this using pointer notation (not index [ ] notation).
5. Write a function which is passed two char pointers and prints all the chars in memory between the two pointers.
6. Write a function called sum. the function should take two pointers to ints. It should put the value of the sum of the two ints into the first int. it should return void.
7. write a function called swap. It should take two pointers to floats and swap the values from the first float to the second and from the second to the first. After this function is called in the main() the actually variables in the main will have switched their values.
8. Write a function which is passed a string. It should capitalize every letter in the string. Characters which are not letters, such as ?,#.; etc. should be left unchanged. You might want to look up the ascii values of the letters and characters, but this is not neccessary.
9. Write a function which is passed an array of int's and the size of that array. It should then create a new array of size "size+1". It should then copy the contents of the old array into the new array, leaving the last element blank. The function should be called expandArray.
10. Write a function which is passed two shorts representing the length and height of a 2-D array. The function should create such an array using new. It should also return a double pointer which points to the newly created array.
11. Write a function to append one string to the end of a second string. The parameters of this function should be two strings as indicated by two char pointers (not arrays). You can however use array notation when copying the arrays.

© Nachum Danzig November 2003 - December 2009