Pointers - Pointer Variables, Call by Reference

Pointers

Pointers are without a doubt one of the most important mechanisms in C. They are the means by which we implement call by reference function calls, they are closely related to arrays and strings in C, they are fundamental to utilising C's dynamic memory allocation features, and they can lead to faster and more efficient code when used correctly.

A pointer is a variable that is used to store a memory address. Most commonly the address is the location of another variable in memory.

If one variable holds the address of another then it is said to point to the second variable.

In the above illustration ivar is a variable of type int with a value 23 and stored at memory location 1012. ivar_ptr is a variable of type pointer to int which has a value of 1012 and is stored at memory location 1004. Thus ivar_ptr is said to point to the variable ivar and allows us to refer indirectly to it in memory.

NB : It should be remembered that ivar_ptr is a variable itself with a specific piece of memory associated with it, in this 32-bit case four bytes at address 1004 which is used to store an address.

1 Pointer Variables

Pointers like all other variables in C must be declared as such prior to use.

Syntax : type  *ptr ;

which indicates that ptr is a pointer to a variable of type type. For example

int *ptr ;

declares a pointer ptr to variables of type int

NB : The type of the pointer variable ptr is int * The declaration of a pointer variable normally sets aside just two or four bytes of storage for the pointer whatever it is defined to point to.

In 16-bit systems two byte pointers are termed near pointers and are used in small memory model programs where all addresses are just segment offset addresses and 16 bits in length. In larger memory model programs addresses include segment and offset addresses and are 32 bits long and thus pointers are 4 bytes in size and are termed far pointers.

In 32-bit systems we have a flat address system where every part of memory is accessible using 32-bit pointers.

2 Pointer Operators * and &

& is a unary operator that returns the address of its operand which must be a variable.

For Example :-

int *m ;

int count=125, i ;/* m is a pointer to int, count, i are integers */

m = &count ;

The address of the variable count is placed in the pointer variable m.

The * operator is the complement of the address operator & and is normally termed the indirection operator. Like the & operator it is a unary operator and it returns the value of the variable located at the address its operand stores.

For Example :-

i = *m ;

assigns the value which is located at the memory location whose address is stored in m, to the integer i. So essentially in this case we have assigned the value of the variable count to the variable i. The final situation is illustrated below.

One of the most frequent causes of error when dealing with pointers is using an uninitialised pointer. Pointers should be initialised when they are declared or in an assignment statement. Like any variable if you do not specifically assign a value to a pointer variable it may contain any value. This is extremely dangerous when dealing with pointers because the pointer may point to any arbitrary location in memory, possibly to an unused location but also possibly to a memory location that is used by the operating system. If your program tries to change the value at this address it may cause the whole system to crash. Therefore it is important to initialise all pointers before use either explicitly in your program or when defining the pointer.

A pointer may also be initialised to 0 ( zero ) or NULL which means it is pointing at nothing. This will cause a run-time error if the pointer is inadvertently used in this state. It is useful to be able to test if a pointer has a null value or not as a means of determining if it is pointing at something useful in a program.

NB : NULL is #defined in <stdio.h>.

For Example :-

int var1, var2 ;

int *ptr1, *ptr2 = &var2 ;

int *ptr3 = NULL ;

ptr1 = &var1 ;

ptr1 and ptr2 are now pointing to data locations within the program so we are free to manipulate them at will i.e. we are free to manipulate the piece of memory they point to.

3 Call by Reference

Recall when we wanted to swap two values using a function we were unable to actually swap the calling parameters as the call by value standard was employed. The solution to the problem is to use call by reference which is implemented in C by using pointers as is illustrated in the following example.

#include <stdio.h>

void swap( int *, int * ) ;

void main( )

void swap ( int *ptr1, int *ptr2 )

The swap() function is now written to take integer pointers as parameters and so is called in main() as

swap( &a, &b ) ;

where the addresses of the variables are passed and copied into the pointer variables in the parameter list of swap(). These pointers must be de-referenced to manipulate the values, and it is values in the the same memory locations as in main() we are swapping unlike the previous version of swap where we were only swapping local data values.

In our earlier call-by-value version of the program we called the function from main() as swap(a,b) and the values of these two calling arguments were copied into the formal arguments of function swap.

In our call-by-reference version above our formal arguments are pointers to int and it is the addresses contained in these pointers, (i.e. the pointer values), that are copied here into the formal arguments of the function. However when we de-reference these pointers we are accessing the values in the main() function as their addresses do not change.

4 Pointers and Arrays

There is a very close relationship between pointer and array notation in C. As we have seen already the name of an array ( or string ) is actually the address in memory of the array and so it is essentially a constant pointer.

For Example :-

char str[80], *ptr ;

ptr = str ;/* causes ptr to point to start of string str */

ptr = &str[0] ;  /* this performs the same as above */

It is illegal however to do the following

str = ptr ; /* illegal */

as str is a constant pointer and so its value i.e. the address it holds cannot be changed.

Instead of using the normal method of accessing array elements using an index we can

use pointers in much the same way to access them as follows.

char str[80], *ptr , ch;

ptr = str ; // position the pointer appropriately

*ptr = 'a' ;  // access first element i.e. str[0]

ch = *( ptr + 1 ) ; // access second element i.e. str[1]

Thus *( array + index ) is equivalent to array[index].

Note that the parentheses are necessary above as the precedence of * is higher than that of +. The expression

ch = *ptr + 1 ;

for example says to access the character pointed to by ptr ( str[0] in above example with value 'a') and to add the value 1 to it. This causes the ASCII value of 'a' to be incremented by 1 so that the value assigned to the variable ch is 'b'.

In fact so close is the relationship between the two forms that we can do the following

int x[10], *ptr ;

ptr = x ;

ptr[4] = 10 ;  /* accesses element 5 of array by indexing a pointer */

5 Pointer Arithmetic

Pointer variables can be manipulated in certain limited ways. Many of the manipulations are most useful when dealing with arrays which are stored in contiguous memory locations. Knowing the layout of memory enables us to traverse it using a pointer and not get completely lost.

Assignment

int count, *p1, *p2 ;

p1 = &count ; // assign the address of a variable directly

p2 = p1 ; // assign the value of another pointer variable, an address

Addition / Subtraction

The value a pointer holds is just the address of a variable in memory, which is normally a four byte entity. It is possible to modify this address by integer addition and subtraction if necessary. Consider the following we assume a 32-bit system and hence 32-bit integers.

We now have the pointer variable ptr pointing at the start of array which is stored at memory location 2008 in our illustration. Since we know that element array[1] is stored at address 2012 directly after element array[0] we could perform the following to access its value using the pointer.

ptr += 1 ;

This surprisingly will cause ptr to hold the value 1012 which is the address of array[1], so we can access the value of element array[1]. The reason for this is that ptr is defined to be a pointer to type int, which are four bytes in size on a 32-bit system. When we add 1 to ptr what we want to happen is to point to the next integer in memory. Since an integer requires four bytes of storage the compiler increments ptr by 4. Likewise a pointer to type char would be incremented by 1, a pointer to float by 4, etc.

Similarly we can carry out integer subtraction to move the pointer backwards in memory.

ptr = ptr - 1 ;

ptr -= 10 ;

The shorthand operators ++ and -- can also be used with pointers. In our continuing example with integers the statement ptr++ ; will cause the address in ptr to be incremented by 4 and so point to the next integer in memory and similarly ptr-- ; will cause the address in ptr to be decremented by 4 and point to the previous integer in memory.

NB : Two pointer variables may not be added together ( it does not make any logical sense ).

char *p1, *p2 ;

p1 = p1 + p2 ; /* illegal operation */

Two pointers may however be subtracted as follows.

int *p1, *p2, array[3], count ;

p1 = array ;

p2 = &array[2] ;

count = p2 - p1 ; /* legal */

The result of such an operation is not however a pointer, it is the number of elements of the base type of the pointer that lie between the two pointers in memory.

Comparisons

We can compare pointers using the relational operators ==, <, and > to establish whether two pointers point to the same location, to a lower location in memory, or to a higher location in memory. These operations are again used in conjunction with arrays when dealing with sorting algorithms etc.

For Example :- Writing our own version of the puts() standard library function.

Using array notation

void puts( const char s[ ] ) /* const keyword makes string

contents read only */

Using pointer notation

void puts( const char *s ) // char *const s would make pointer unalterable

As you can see by comparing the two versions above the second version using pointers is a much simpler version of the function. No extra variables are required and it is more efficient as we will see because of its use of pointer indirection.

For Example :- Palindrome program using pointers.

#include <stdio.h>

int palin( char * ) ; /* Function to determine if array is a palindrome. returns 1 if it is a palindrome, 0 otherwise */

void main( )

int palin ( char *str )

Strings and pointers

C's standard library string handling functions use pointers to manipulate the strings. For example the prototype for the strcmp() function found in <string.h> is

int strcmp( const char *string1, const char *string2 ) ;

where const is a C keyword which locks the variable it is associated with and prevents any inadvertent changes to it within the function.

Strings can be initialised using pointer or array notation as follows

char *str = 'Hellon' ;

char string[] = 'Hellon' ;

in both cases the compiler allocates just sufficient storage for both strings.

6 Arrays of Pointers

It is possible to declare arrays of pointers in C the same as any other 'type'. For example

int *x[10] ;

declares an array of ten integer pointers.

To make one of the pointers point to a variable one might do the following.

x[ 2 ] = &var ;

To access the value pointed to by x[ 2 ] we would do the following

*x[ 2 ]

which simply de-references the pointer x[ 2 ] using the * operator.

Passing this array to a function can be done by treating it the same as a normal array which happens to be an array of elements of type int *.

For Example : -

void display( int *q[ ], int size )

Note that q is actually a pointer to an array of pointers as we will see later on with multiple indirection.

A common use of pointer arrays is to hold arrays of strings.

For Example :- A function to print error messages.

void serror( int num )

;

puts( err[num] );

}

Note that using an array of pointers to char initialised as above conserves space as no blank filling characters are required as would be if we used

char err[3][30] = ;

7 Command Line Arguments

Command line arguments allow us to pass information into the program as it is run. For example the simple operating system command type uses command line arguments as follows

c:>type text.dat

where the name of the file to be printed is taken into the type program and the contents of the file then printed out.

In C there are two in-built arguments to the main() function commonly called argc and argv which are used to process command line arguments.

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

argc is used to hold the total number of arguments used on the command line which is always at least one because the program name is considered the first command line argument.

argv is a pointer to an array of pointers to strings where each element in argv points to a command line argument. For example argv[0] points to the first string, the program name.

For Example :- Program to print a name ( saved in name.c ) using command line arguments.

#include <stdio.h>

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

printf( 'Hello %s', argv[1] ) ;

}

To run the program one might type

c:>name tom

For Example :- Program to count down from a given value, the countdown being displayed if the argument 'display' is given.

#include <stdio.h>

#include <stdlib.h>

#include <ctype.h>

#include <string.h>

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

if ( argc > 2 && !strcmp( argv[2], 'display' ) )

disp = 1 ;

else

disp = 0 ;

for ( count = atoi( argv[1] ) ; count ; count-- )

if ( disp )

printf( '%dn', count ) ;

printf( "donen" ) ;

}

NB : C has a broad range of functions to convert strings into the standard data types and vice versa. For example atoi() converts a string to an integer above - remember all command line arguments are just character strings.

8 Dynamic Memory Allocation

This is the means by which a program can obtain and release memory at run-time. This is very important in the case of programs which use large data items e.g. databases which may need to allocate variable amounts of memory or which might have finished with a particular data block and want to release the memory used to store it for other uses.

The functions malloc() and free() form the core of C's dynamic memory allocation and are prototyped in <malloc.h>. malloc() allocates memory from the heap i.e. unused memory while available and free() releases memory back to the heap.

The following is the prototype for the malloc() function

void * malloc( size_t num_bytes ) ;

malloc() allocates num_bytes bytes of storage and returns a pointer to type void to the block of memory if successful, which can be cast to whatever type is required. If malloc() is unable to allocate the requested amount of memory it returns a NULL pointer.

For example to allocate memory for 100 characters we might do the following

#include <malloc.h>

void main()

}

The return type void * is automatically cast to the type of the lvalue type but to make it more explicit we would do the following

if ( !( (char * )p = malloc( sizeof( char ) * 100 ) )

To free the block of memory allocated we do the following

free ( p ) ;

Note :- There are a number of memory allocation functions included in the standard library including calloc( ), _fmalloc( ) etc. Care must be taken to ensure that memory allocated with a particular allocation function is released with its appropriate deallocation function, e.g. memory allocated with malloc() is freed only with free() .

9 Multiple Indirection -- Pointers to Pointers

It is possible in C to have a pointer point to another pointer that points to a target value. This is termed multiple indirection in this case double indirection. Multiple indirection can be carried out to whatever extent is desired but can get convoluted if carried to extremes.

In the normal situation, single indirection, a pointer variable would hold the address in memory of an appropriate variable, which could then be accessed indirectly by de-referencing the pointer using the * operator.

In the case of double indirection, we have the situation where a variable may be pointed to by a pointer as with single indirection, but that this pointer may also be pointed to by another pointer. So we have the situation where we must de-reference this latter pointer twice to actually access the variable we are interested in. De-referencing the pointer to a pointer once gives us a normal singly indirected pointer, de-referencing the pointer to a pointer secondly allows us to access the actual data variable. The situation is depicted in the diagram below.

To declare a pointer to a pointer we include another indirection operator

float * * ptr ;

which in this case defines a pointer to a pointer to type float.

The following illustrates some valid operations using double indirection.

int x = 10, *p, **q ;

p = &x ;

q = &p ;

**q = 20 ; // de-reference twice to access value

p = *q ; // de-reference q once to get a pointer to int

.

int array1[] = ;

int array2[] = ;

int *pointers[2] ; // an array of pointers to type int

int **ptr ;  // a doubly indirected pointer

ptr = pointers ;  // initialise pointer to array of pointers

*ptr++ = array1 ; // now we simply de-reference the pointer to a pointer

*ptr = array2 ;  // once and move it on like any pointer

**ptr = 100 ; // ptr is pointing at pointers[1] which in turn is pointing
// at array2 so array2[0] is assigned 100

For Example :- Allocation and initialisation of an m x n matrix using double indirection

What we require here is to allocate an n x n matrix as a collection of discrete rows rather than just as one block of memory. This format has advantages over a single block allocation in certain situations. The structure we end up with is illustrated below.

#include <stdio.h>

#include <malloc.h>

void main( void )

// after use we need to clean up in reverse order

user_ptr = ptr_rows ;

for ( i = 0; i < n; i++ )

free( *user_ptr ++ ) ; // free a row and move onto next

free( ptr_rows ) ;  // free pointers to rows

10 Pointers to Functions

A function even though not a variable still has a physical address in memory and this address may be assigned to a pointer. When a function is called it essentially causes an execution jump in the program to the location in memory where the instructions contained in the function are stored so it is possible to call a function using a pointer to a function.

The address of a function is obtained by just using the function name without any parentheses, parameters or return type in much the same way as the name of an array is the address of the array.

A pointer to a function is declared as follows

Syntax : ret_type ( * fptr ) ( parameter list ) ;

where fptr is declared to be a pointer to a function which takes parameters of the form indicated in the parameter list and returns a value of type ret_type.

The parentheses around * fptr are required because without them the declaration

ret_type * fptr( parameter list ) ;

just declares a function fptr which returns a pointer to type ret_type !

To assign a function to a pointer we might simply do the following

int (*fptr)( ) ;

fptr = getchar ; /* standard library function */

To call the function using a pointer we can do either of the following

ch = (*fptr)( ) ;

ch = fptr( ) ;

Example :- Program to compare two strings using a comparison function passed as a parameter.

#include <stdio.h>

#include <string.h>

void check( char *a, char *b, int ( * cmp ) ( ) );

void main( )

void check ( char *a, char *b, int (* cmp)( ) )

Note that even though we do not specify parameters to the function pointer in the prototype or declarator of the function we must specify them when actually calling the function.

Note also that instead of using an explicitly declared pointer variable to call the required function in main() we could make the call as follows

check( s1, s2, strcmp ) ;

where we essentially pass a constant pointer to strcmp( ).

For Example : Program that may check for either numeric or alphabetic equality.

#include <stdio.h>

#include <ctype.h>

#include <stdlib.h>

#include <string.h>

void check( char *a, char *b, int ( * cmp ) ( ) );

int numcmp( char *, char * ) ;

void main( )

void check ( char *a, char *b, int (* cmp)( ) )

int numcmp( char *a, char *b )

11 Efficiency Considerations

When used correctly pointers can lead to more efficient code in situations where sequential operations on contiguous blocks of memory are required.

For example when accessing each element of an array sequentially. The inefficient way to do this is

for ( k = 0; k < 100; k++ )

array[ k ] = 0.0 ;

When done this way the compiler has to index into the array for each iteration of the loop. This involves reading the current value of the index, k, multiplying this by the sizeof( double ) and using this value as an offset from the start of the array.

The exact same thing occurs if we use a pointer incorrectly as follows

ptr = array ;

for ( k = 0; k < 100; k++ )

*( ptr + k ) = 0.0 ;

whereas the most efficient solution is of course to do the following where the pointer itself is moved by the appropriate amount.

ptr = array ;

for ( k = 0; k < 100; k++ )

*ptr++ = 0.0 ;

In this case we just incur the addition of sizeof( double ) onto the address contained in the pointer variable for each iteration.

12 Exercises

Write your own functions to carry out some of the standard string manipulation tasks included in the standard library, e.g.. strcpy(), strcat(), strlen(), strstr( ).

Use the same prototypes as the standard functions but use slightly different function names in order to be able to test the functions in parallel with the originals.

There is a logical bug in the following program. Compile run and debug the program and see if

you can find it.

#include <stdio.h>

#include <string.h>

void main()

while(strcmp(s, 'done') ) ;

}

The following program section contains a logical error. Run the program and explain what happens.

#include <stdio.h>

#include <string.h>

void main()

Use a simple bubble sort algorithm to sort an array of characters into alphabetical order.

The bubble sort algorithm is as follows. Starting at the beginning of the array examine the first pair of adjacent elements and exchange their values if not in the correct order. Next move on by one element to the next pair of values - the pairs will overlap with the previous pair so that the second element of the first pair becomes the first element of the second pair. Examine the ordering of this pair as before. After the first pass of the bubble sort over the complete array the last array element is in the correct position, after the second pass the second last is in position, etc. Thus after each pass the unsorted portion of the array contains one less element. This procedure should be repeated until either a complete pass in which no swaps are required is made or in the worst case until one less than the total number of elements number of passes have been made.

Write a program which sets up an array of pointers to char which are initialised to days of the week say. Write and test a function which takes an integer parameter to print out the corresponding

day .

e.g.. 1 --- Sunday, 2 --- Monday, etc.

The function should print out an invalid message if an incorrect number is passed to it.

Write and test a program to sort a list of words into alphabetical order. The standard library string handling functions may be used. A maximum number of words to be sorted and a maximum length of each word should be specified in the interest of memory requirements e.g. limit the number of words to 5 and the length of each word to 10 .

Write and test a function which can perform unsigned integer addition with up to 50 digits of

precision maintained.

For Example :-

9123412341234123412341234123412341234

1123412341234123412341234123412341234

10246824682468246824682468246824682468

The program should read in the two operands and present the result of the operation as well as the two operands.

Note : There is no C data type which can maintain up to 50 digits of precision.

Write a simple function e.g. to add two numbers and define a pointer to this function to call the

function.

Write a program which will calculate and print out the values of various trigonometric operations from 0 rad to 2*PI rad at intervals of PI/4.

The trigonometric operations supported ( sin, cos, tan , etc.) should be entered as command line

parameters. e.g.

A:>trigprog sin

A single generic function should be used to compute and print out the values of the operation requested taking a pointer to the appropriate standard library function as a parameter.

Prototypes for the C standard library maths functions are included in <math.h>.

Write a program which will sort an array of integers using the standard library qsort() function. The qsort() function requires a pointer to a user supplied comparison function as a parameter which might have the following prototype

int comp( int *p1, int *p2 ) ;

A return value of 0 indicates equality, a return value of 1 indicates element *p1 > element *p2, and

a return value of -1 indicates element *p1 < element *p2.

11. Programming Assignment : Base Conversion Program

Your task in this assignment is to write a C program which converts an unsigned short in a specified number base, base1, to another number base, base2.

The number to be converted is to be entered into the program as an ASCII string and the two bases, base1 and base2, as integers in base 10. The program must then convert the number in base1 to base2 and output the results for the user, continuing until an EOF is encountered ( see later ).

For Example :- the following input should cause an output statement like that presented below.

12 10 2

12 in base 10 is 1100 in base 2

Only base values in the range 2 -- 10 inclusive are to be allowed in the program, so you should check

that base1 and base2 are appropriate base values and

that the number string entered does not contain any invalid digits, i.e. digits outside the range for base1 (or indeed any alphabetic characters, but it may skip leading white-space characters )

before attempting any conversions. In either case your program should ignore the values completely and write out an appropriate error message to the output and then continue with the program.

To convert a number in base1 to base2 it may be simpler to carry out the operation in two steps as follows

Convert number string in base1 to number in base 10 and check that it is in range for unsigned short.

Convert base 10 number to base2 number string.

To carry out these two tasks you should provide two functions with the following prototypes

unsigned short convert_10( char *ptr, unsigned short base_b ) ;

char *convert_b( unsigned short num_10, unsigned short base_b );

The convert_10( ) function takes a pointer to an ASCII string which contains a number in base_b and should return this number as a base 10 unsigned integer.

For Example :- 23 in base 4 = 2 x 4¹ + 3 x 4⁰ = 8 + 3 = 11 in base 10.

Your function should check that the value does not exceed the value for an unsigned short and return an error value if it does. ( Suggestion : Make 0 -- 65534 valid values and use 65535 as an error return.)

The function convert_b( ) takes a valid integer in base 10 as its first parameter and converts it to a number in base_b, which you must represent as an ASCII string.

Your function should return a pointer to a string containing the number in base_b, which should be tailored down so that the bare minimum of space is used ( i.e. dynamically allocated once the number has been converted ). This pointer may be freed in the calling function once it has finished with the number string in question.

For Example : Convert 12 base 10 to base 2 as follows

Your program should be written so that it accepts a number of optional command line arguments as follows

progname [source_file] [ destination_file]

If no command line arguments are present the program should read its input from stdin, the keyboard and write the results to stdout, the monitor.

If one command line argument is present it means that the program is to take its input from the file specified if possible where it is arranged as follows

12 10 2

24 5 7

and write the results to the standard output.

Lastly if two arguments are given the program is to read its input from the specified file and write the results to the specified destination file.

In all cases your program is to continue reading input from the input device in question until an EOF is encountered ( or until a conversion error occurs ). Note that EOF may be produced at the keyboard by Ctrl+Z.

Note : You may not use any of the following family of functions in your program for any reason unless you implement your own versions of them.

atoi( ), atol( ), itoa( ), ltoa( ), etc.

12. Programming Assignment : Tabulation Program.

Your main task in this assignment is to write and test a function

int *tabulate( int *data, int numvals ) ;

This function takes as its parameters a pointer to an array of integers and the number of integers in this array and should tabulate the values in the array storing the results in a second array and returning it as the functions return value.

Your main program is to first read in a user specified number of integers from the keyboard and store them in a dynamically allocated array and then call the tabulate function.

The tabulate function must first determine the range of the data being passed to it i.e. the maximum and minimum values it contains and then allocate a block of memory covering this range. For example if the data set was then min = 6 and max = 10 so we need to allocate a block of ( max - min + 1 ) = 5 integers to contain all values in the range. The first element in the array is for the value 6, the second for 7, etc.

We also need to store the max and min range values which tells us how many data values are in the array. To do this we modify the above representation so that we allocate two extra elements to store the range. The first element in the array is deemed to be for the minimum, the second for the maximum and the remainder for the data as before.

This new block of data is next initialised to zero i.e. no instances of any of the values in the range are present in the data. The data would look as follows with our above example.

The function should now look at the data set and increment the count associated with all the elements in it appropriately. The data set should now look like the following and will be returned to the main program where the results will be displayed.

Your program is also required to accept one extra command line argument. If this can be opened as a file the results of the tabulation are to be printed to it otherwise they are to be printed to stdout.

13. Programming Assignment : Polynomial Parser

The basic requirement of this assignment is to write a C program which can resolve a simple polynomial into a vector of its components and to make use of this form to implement differentiation of the equation.

The equation parser should be implemented as a function which is passed an ASCII character string which is used to represent a polynomial of degree n which has the general form

where x is the dependant variable, a_n are the coefficients of the polynomial (which may be limited to signed integer values).

The character string representation may be of any degree, n, and the components may be in any random order and may even be repeated. Use the '^' character to represent to the power of. The character string may also include white space characters for readability, namely the space character, which do not convey any information but which nonetheless must be processed being part of the string. Some examples of valid equations are given below where '_' represents the space character.

1 + x + 2x^2 + 5x^4

2x^4 + 3x -12

-6 + 2x^3 - 2x + 4 - x

-4 x^-2 + x^-1+ 2x^3

x_^_2_+_2_x_^_3

The equation parser must resolve the polynomial into a vector representation, ie. it must establish a value for the coefficient of each component of the polynomial. This information or vector should be stored in a single dimension integer array where the index into the array represents a specific component of the vector. Vector[0] represents the coefficient of x^0, Vector[1] represents the coefficient of x^1, and so on up to the degree of the polynomial.

The size of the vector array should be just sufficient to store the required vector, memory being allocated dynamically once the degree of the polynomial has been established. For example a polynomial of degree 2 would require an array of three elements to store all the component coefficients.

For testing purposes your program should first of all take in a polynomial in the form of a character string as input, resolve this into a vector using the parser function, and then pass this vector to a function which should differentiate the vector ( or equation ) and store the result in a different vector of appropriate dimension.

The results of each operation should be displayed in tabular form as illustrated in the following example where the equation input was 5x^3 + 3x^2 - x + 4.

Coefficients :  x^0 x^1 x^2 x^3

Equation :  4 -1 3 5

Equation' : -1 6 15

The results of the operation should also be stored to a user specified text file in the same tabular form as above. In the case where the file specified already exists and has a number of valid entries, the new entry to be added should be separated by a blank line from the others for readability.