none so far.
By the end of your last lab of week 8.
To learn about strings.
To practice applying what you know about arrays to strings.
To learn about some of the more common string functions from the standard library by re-implementing them.
To learn to write functions that take strings as parameters.
A string in C is almost the same as an array of char. In fact,
most (but not all) arrays of char you'll see turn out to be
strings. The only difference is that to qualify as a string, an array of
char, or any other sequence of char in computer
memory needs one other property: it is terminated (ended) with a "NULL"
character. This is the character with the value zero, and is the first
one in the ASCII code set. It is not considered part of the contents of
the string, but servers merely as a marker of the end.
Using the NULL in this way causes a few oddities that are common to the handling of character strings throughout the C libraries. For one thing, a string cannot contain a NULL because any NULL marks the end of the string and thus cannot be in the contents. For another, strings always use one more byte of memory than you'd think at first -- they have to have the contents plus one byte for the terminator.
With the end of a string marked by a NULL, any program that manipulates strings has to be careful about the NULL, to preserve it when that is called for and to place a new NULL when that is called for. The programmer always needs to keep this NULL in mind whenever thinking about strings.
In this lab, you will re-implement a number of the string functions that occur in the C Standard Library, to get a feel for how strings are handled.
The C Standard Libarary usually gives strings the type "char *",
but the same string could usually be declared as a character array instead.
We'll take up "char *" when we cover pointers later on.
There's just one important rule for this lab: you must not use any of
the Standard Library functions, or their header files
<string.h> and <strings.h>. Write the
entire body of each string function using the basic tools for working with
arrays of char. You can also have any of your own "my"functions in the
code for the more complicated ones.
A test program that tests your functions. Try to pass all the tests. Do not modify the test program.
In order to use the symbol NULL and data type size_t, you
may find it handy to
#include <stddef.h>
In a file called stringFuncts.c write
functions that do exactly what the corresponding Standard Library functions do
without using any of the Standard Library funcions, and also without
#include-ing <string.h> or
<string.h>. Check the man pages for descriptions, or look
them up in any other reference. You'll have to figure out the function
prototypes yourself from that documentation. You can ignore the keyword
const that shows up in a lot of them. Functions that return a
char * can be satisfied with the address of a char, or of the
first char of a string. The data type size_t that shows up from time
to time can be used interchangeably (for this lab) with an int.
mystrlen like strlen (string length)
mystrcpy like strcpy (string copy)
mystrncpy like strncpy (string copy with length limit)
mystrchr like strchr (find a char)
mystrrchr like strrchr (find last char)
mystrstr like strstr (find a substring)
mystrcat like strcat (concatenate)
mystrncat like strncat (concatenate with a length limit)
mystrcmp like strcmp ( compare)
mystrncmp like strncmp (compare with a length limit)
There are lots of ways to approach this problem, but probably the best ones include starting with "stub" functions. These are minimal implementations of the function that are just good enough to get past the compiler, but generally not good enough to actually work or to pass any tests.
For example, you could "stub" the first function like this:
int mystrlen(char *string)
{
return 0;
}
Note that the stubbed function still has to have the right function signature, and if it's supposed to return a value, it has to return something of the correct data type. It just doesn't have to be correct (not at first, anyway,) and for a stub program it may as well be some constant like zero.
Do the same thing with the other 9 functions, and compile the whole thing:
gcc -ansi -pedantic -Wall -o lab8 lab8test.c stringFuncts.c
Fix any problems the compiler has, and you should be able to run the program. Of course, this stub program is going to fail just about all of the tests (it might pass a few, like the very first one, where the correct answer just happens to be zero.)
Now you can pick a function and work on it until it passes all of its tests. You can tell, because each test set is designed to test one of the functions and there are 10 sets, just as there are 10 functions.
It would be good to start with mystrlen, mystrcpy,
and mystrncpy because these may be useful in the implementation
of some of the other functions. You'd like them to be working so they are not
the cause of any failures of the other functions when you get to them.
11:59 vogon ~$ handin mhaungs Lab08-yy stringFuncts.c