Books / C Language Primer for Java Developers / Chapter 5
Strings in C vs Java
Like Java, we use single quotes ('a'
) to designate a char
acter , and double quotes
("..."
) to designate a string. However, C does not have a devoted string
type
in the same way that Java does (the String
class). Instead, you must use char
arrays. For
example, the following creates a string that holds the word “hello”:
char myGreeting[] = "hello"; // char array used as string
The length of this array will be 6: every string must end with a 0
(the null
character), to designate the end of the string. Therefore myGreeting[0]
will hold the char 'h'
(equivalent to the int 104), myGreeting[1]
will hold
'e'
(or 101), and so on, until myGreeting[5]
holds 0.
Even though strings are really arrays, C has many built-in functions to
make their use easier. Most of the functions detailed in this section are
defined in the string.h header file, so be sure to #include
it!
Inputting a string from the user can be difficult, because the programmer
must make absolutely certain that enough memory has been pre-allocated
to store it. Not doing so can result in very confusing bugs, since it might
overwrite unrelated data. It might even result in a security hole in your
program. The easiest way to get a string is with the fgets()
function.
Note: You may find online code that uses gets() instead of
fgets()
. DO NOT USE IT! gets() has serious security issues, that can allow a malicious hacker to gain control of a computer that is running your program. We will talk about this more in the next section.
Here we assume that a constant BUFFER SIZE has already been defined:
char string[BUFFER SIZE]; // temporarily allocate space
printf("Enter a string: ");
fgets(string, BUFFER SIZE, stdin); // input a string
The first argument to fgets()
is the array of characters that has been preallocated for the string. There is no need for the &
because string is already
an array, and can be modified when it’s an argument to a function. The
second argument is the maximum size that can be input: the string will automatically be truncated down to the right size to fit in the array,
so that nothing gets accidentally overwritten. (Remember, the last
element of the array must be 0.) And the third argument is the
standard-in stream, stating where to get the information. stdin is
defined inside of stdio.h.
There are a number of standard functions made to work with strings. If
you wish to use them, be sure to #include <string.h>
at the
beginning of your code. The simplest is strlen()
, which finds the
length of a string:
int length = strlen(myGreeting); // length of myGreeting
This will search the given char array for the first 0, returning its
index. So if myGreeting contains “hello”, the above code will return 5
. It takes linear time to run, since it must search for the 0.
Use the strcmp()
function to compare two strings. This will return 0
if the strings are equal:
if (!strcmp(string1, string2)) { // triggers if identical
If the strings are not equal, strcmp()
returns an int based on the
ordering of the two strings. It returns a negative number if the first
string comes first, and a positive number if the second string comes
first. It does this based on an order that is similar to alphabetical
order, but using each char’s numerical value. The comparison will be
alphabetical if the strings consist of only lowercase letters. But all
numbers come before all letters, and all capital letters come before
all lowercase letters.
Note: Look up the “ASCII table” if you wish to see the exact ordering.
strcpy()
is used to copy one string into another. Its two arguments
are the location to copy the string to, and the original string. For
example:
strcpy(copyString, originalString); // copies a string
Note that you are responsible for making sure that the destination
string already has all the space it needs for the data being copied
into it! All strcpy()
does is take the characters from one string and
copy them into the new string. It doesn’t allocate any new space on
its own. If you do not do this first, your program will likely
overwrite unrelated data or terminate.
For example:
char[strlen(originalString)+1] copyString; // allocation
Note that the +1 is to make space for the 0 that must be at the end of every string.
The function strcat()
is used to concatenate two strings. It looks
much like strcpy()
:
strcat(mainString, suffix); // concatenates suffix to end
Here, the string suffix is tacked to the end of mainString,
permanently altering mainString. As with strcpy()
, you are responsible
for making sure that mainString has enough space already allocated,
for this to be a legitimate operation. If there is not, you may write
over unrelated data or cause your program to crash!
Finally, there is a function called sprintf()
that can mimic much of
the above functionality. sprintf()
is identical to printf()
detailed
above, except that it takes an additional argument before the others
indicating a string to write into. It does not print anything to the
screen at all:
sprintf(string, "The value is %d.", value); // saves string
As always, you must make sure that the first string argument contains the space needed, or else risk writing over unrelated data.