Now, it is time to go back to the concat function developed in Program 10.1 and rewrite it to work with variable-length character strings. Obviously, the function must be changed somewhat because you no longer want to pass as arguments the number of characters in the two arrays. The function now takes only three arguments: the two character arrays to be concatenated and the character array in which to place the result.

Before delving into this program, you should first learn about two nice features that C provides for dealing with character strings.

The first feature involves the initialization of character arrays. C permits a character array to be initialized by simply specifying a constant character string rather than a list of individual characters. So, for example, the statement

char  word[] = { "Hello!" };

can be used to set up an array of characters called word with the initial characters ‘H’, ‘e’, ‘l’, ‘l’, ‘o’, ‘!’, and ‘’, respectively. You can also omit the braces when initializing character arrays in this manner. So, the statement

char word[] =  "Hello!";

is perfectly valid. Either statement is equivalent to the statement

char  word[] = { 'H', 'e', 'l', 'l', 'o', '!', '' };

If you’re explicitly specifying the size of the array, make certain you leave enough space for the terminating null character. So, in

char  word[7] = { "Hello!" };

the compiler has enough room in the array to place the terminating null character. However, in

char  word[6] = { "Hello!" };

the compiler can’t fit a terminating null character at the end of the array, and so it doesn’t put one there (and it doesn’t complain about it either).

In general, wherever they appear in your program, character-string constants in the C language are automatically terminated by the null character. This fact helps functions such as printf determine when the end of a character string has been reached. So, in the call

printf ("Programming in C is fun.
");

the null character is automatically placed after the newline character in the character string, thereby enabling the printf function to determine when it has reached the end of the format string.

The other feature to be mentioned here involves the display of character strings. The special format characters %s inside a printf format string can be used to display an array of characters that is terminated by the null character. So, if word is a null-terminated array of characters, the printf call

printf ("%s
", word);

can be used to display the entire contents of the word array at the terminal. The printf function assumes when it encounters the %s format characters that the corresponding argument is a character string that is terminated by a null character.

The two features just described were incorporated into the main routine of Program 10.3, which illustrates your revised concat function. Because you are no longer passing the number of characters in each string as arguments to the function, the function must determine when the end of each string is reached by testing for the null character. Also, when str1 is copied into the result array, you want to be certain not to also copy the null character because this ends the string in the result array right there. You do need, however, to place a null character into the result array after str2 has been copied so as to signal the end of the newly created string.

#include <stdio.h>

int main (void)
{
    void  concat (char  result[], const char  str1[], const char  str2[]);
    const char  s1[] = { "Test " };
    const char  s2[] = { "works." };
    char  s3[20];

    concat (s3, s1, s2);

    printf ("%s
", s3);

    return 0;
}

// Function to concatenate two character strings

void concat (char  result[], const char  str1[], const char  str2[])
{
    int  i, j;

    // copy str1 to result

    for ( i = 0;  str1[i] != '';  ++i )
        result[i] = str1[i];

    // copy str2 to result

    for ( j = 0;  str2[j] != '';  ++j )
        result[i + j] = str2[j];

    // Terminate the concatenated string with a null character

    result [i + j] = '';
}

Test works.

In the first for loop of the concat function, the characters contained inside str1 are copied into the result array until the null character is reached. Because the for loop terminates as soon as the null character is matched, it does not get copied into the result array.

In the second loop, the characters from str2 are copied into the result array directly after the final character from str1. This loop makes use of the fact that when the previous for loop finished execution, the value of i was equal to the number of characters in str1, excluding the null character. Therefore, the assignment statement

result[i + j] = str2[j];

is used to copy the characters from str2 into the proper locations of result.

After the second loop is completed, the concat function puts a null character at the end of the string. Study the function to ensure that you understand the use of i and j. Many program errors when dealing with character strings involve the use of an index number that is off by 1 in either direction.

Remember, to reference the first character of an array, an index number of 0 is used. In addition, if a character array string contains n characters, excluding the null byte, then string[n – 1] references the last (nonnull) character in the string, whereas string[n] references the null character. Furthermore, string must be defined to contain at least n + 1 characters, bearing in mind that the null character occupies a location in the array.

Returning to the program, the main routine defines two char arrays, s1 and s2, and sets their values using the new initialization technique previously described. The array s3 is defined to contain 20 characters, thus ensuring that sufficient space is reserved for the concatenated character string and saving you from the trouble of having to precisely calculate its size.

The concat function is then called with the three strings s1, s2, and s3 as arguments. The result, as contained in s3 after the concat function returns, is displayed using the %s format characters. Although s3 is defined to contain 20 characters, the printf function only displays characters from the array up to the null character.

You cannot directly test two strings to see if they are equal with a statement such as

if ( string1 == string2 )
   ...

because the equality operator can only be applied to simple variable types, such as floats, ints, or chars, and not to more sophisticated types, such as structures or arrays.

To determine if two strings are equal, you must explicitly compare the two character strings character by character. If you reach the end of both character strings at the same time, and if all of the characters up to that point are identical, the two strings are equal; otherwise, they are not.

It might be a good idea to develop a function that can be used to compare two character strings, as shown in Program 10.4. You can call the function equalStrings and have it take as arguments the two character strings to be compared. Because you are only interested in determining whether the two character strings are equal, you can have the function return a bool value of true (or nonzero) if the two strings are identical, and false (or zero) if they are not. In this way, the function can be used directly inside test statements, such as in

if  ( equalStrings (string1, string2) )
   ...

// Function to determine if two strings are equal

#include <stdio.h>
#include <stdbool.h>

bool equalStrings (const char  s1[], const char  s2[])
{
    int  i = 0;
    bool areEqual;

    while ( s1[i] == s2 [i]  &&
                 s1[i] != '' &&  s2[i] != '' )
        ++i;

    if ( s1[i] == ''  &&  s2[i] == '' )
       areEqual = true;
    else
       areEqual = false;
    return areEqual;
}

int main (void)
{
     bool  equalStrings (const char  s1[], const char  s2[]);
     const char  stra[] = "string compare test";
     const char  strb[] = "string";

     printf ("%i
", equalStrings (stra, strb));
     printf ("%i
", equalStrings (stra, stra));
     printf ("%i
", equalStrings (strb, "string"));

     return 0;
}

0
1
1

The equalStrings function uses a while loop to sequence through the character strings s1 and s2. The loop is executed so long as the two character strings are equal (s1[i] == s2[i]) and so long as the end of either string is not reached (s1[i] != '' && s2[i] != ''). The variable i, which is used as the index number for both arrays, is incremented each time through the while loop.

The if statement that executes after the while loop has terminated determines if you have simultaneously reached the end of both strings s1 and s2. You could have used the statement

if ( s1[i] == s2[i] )
       ...

instead to achieve the same results. If you are at the end of both strings, the strings must be identical, in which case areEqual is set to true and returned to the calling routine. Otherwise, the strings are not identical and areEqual is set to false and returned.

In main, two character arrays stra and strb are set up and assigned the indicated initial values. The first call to the equalStrings function passes these two character arrays as arguments. Because these two strings are not equal, the function correctly returns a value of false, or 0.

The second call to the equalStrings function passes the string stra twice. The function correctly returns a true value to indicate that the two strings are equal, as verified by the program’s output.

The third call to the equalStrings function is a bit more interesting. As you can see from this example, you can pass a constant character string to a function that is expecting an array of characters as an argument. In Chapter 11, “Pointers,” you see how this works. The equalStrings function compares the character string contained in strb to the character string "string" and returns true to indicate that the two strings are equal.

By now, you are used to the idea of displaying a character string using the %s format characters. But what about reading in a character string from your window (or your “terminal window”)? Well, on your system, there are several library functions that you can use to input character strings. The scanf function can be used with the %s format characters to read in a string of characters up to a blank space, tab character, or the end of the line, whichever occurs first. So, the statements

char  string[81];

scanf ("%s", string);

have the effect of reading in a character string typed into your terminal window and storing it inside the character array string. Note that unlike previous scanf calls, in the case of reading strings, the & is not placed before the array name (the reason for this is also explained in Chapter 11).

If the preceding scanf call is executed, and the following characters are entered:

Shawshank

the string "Shawshank" is read in by the scanf function and is stored inside the string array. If the following line of text is typed instead:

iTunes playlist

just the string "iTunes" is stored inside the string array because the blank space after the word scanf terminates the string. If the scanf call is executed again, this time the string "playlist" is stored inside the string array because the scanf function always continues scanning from the most recent character that was read in.

The scanf function automatically terminates the string that is read in with a null character. So, execution of the preceding scanf call with the line of text

abcdefghijklmnopqrstuvwxyz

causes the entire lowercase alphabet to be stored in the first 26 locations of the string array, with string[26] automatically set to the null character.

If s1, s2, and s3 are defined to be character arrays of appropriate sizes, execution of the statement

scanf ("%s%s%s", s1, s2, s3);

with the line of text

micro computer system

results in the assignment of the string "micro" to s1, "computer" to s2, and "system" to s3. If the following line of text is typed instead:

system expansion

it results in the assignment of the string "system" to s1, and "expansion" to s2. Because no further characters appear on the line, the scanf function then waits for more input to be entered from your terminal window.

In Program 10.5, scanf is used to read three character strings.

//  Program to illustrate the %s scanf format characters

#include <stdio.h>

int main (void)
{
    char  s1[81], s2[81], s3[81];

    printf ("Enter text:
");

    scanf ("%s%s%s", s1, s2, s3);

    printf ("
s1 = %s
s2 = %s
s3 = %s
", s1, s2, s3);
    return 0;
}

Enter text:
system expansion
bus

s1 = system
s2 = expansion
s3 = bus

In the preceding program, the scanf function is called to read in three character strings: s1, s2, and s3. Because the first line of text contains only two character strings—where the definition of a character string to scanf is a sequence of characters up to a space, tab, or the end of the line—the program waits for more text to be entered. After this is done, the printf call is used to verify that the strings "system", "expansion", and "bus" are correctly stored inside the string arrays s1, s2, and s3, respectively.

If you type in more than 80 consecutive characters to the preceding program without pressing the spacebar, the tab key, or the Enter (or Return) key, scanf overflows one of the character arrays. This might cause the program to terminate abnormally or cause unpredictable things to happen. Unfortunately, scanf has no way of knowing how large your character arrays are. When handed a %s format, it simply continues to read and store characters until one of the noted terminator characters is reached.

If you place a number after the % in the scanf format string, this tells scanf the maximum number of characters to read. So, if you used the following scanf call:

scanf ("%80s%80s%80s", s1, s2, s3);

instead of the one shown in Program 10.5, scanf knows that no more than 80 characters are to be read and stored into either s1, s2, or s3. (You still have to leave room for the terminating null character that scanf stores at the end of the array. That’s why %80s is used instead of %81s.)

The standard library provides several functions for the express purposes of reading and writing single characters and entire character strings. A function called getchar can be used to read in a single character from the terminal. Repeated calls to the getchar function return successive single characters from the input. When the end of the line is reached, the function returns the newline character ' '. So, if the characters “abc” are typed at the terminal, followed immediately by the Enter (or Return) key, the first call to the getchar function returns the character 'a', the second call returns the character 'b', the third call returns 'c', and the fourth call returns the newline character ' '. A fifth call to this function causes the program to wait for more input to be entered from the terminal.

You might be wondering why you need the getchar function when you already know how to read in a single character with the %c format characters of the scanf function. Using the scanf function for this purpose is a perfectly valid approach; however, the getchar function is a more direct approach because its sole purpose is for reading in single characters, and, therefore, it does not require any arguments. The function returns a single character that might be assigned to a variable or used as desired by the program.

In many text-processing applications, you need to read in an entire line of text. This line of text is frequently stored in a single place—generally called a “buffer”—where it is processed further. Using the scanf call with the %s format characters does not work in such a case because the string is terminated as soon as a space is encountered in the input.

Also available from the function library is a function called gets. The sole purpose of this function—you guessed it—is to read in a single line of text. As an interesting program exercise, Program 10.6 shows how a function similar to the gets function—called readLine here—can be developed using the getchar function. The function takes a single argument: a character array in which the line of text is to be stored. Characters read from the terminal window up to, but not including, the newline character are stored in this array by the function.

#include <stdio.h>

int main (void)
{
    int   i;
    char  line[81];
    void  readLine (char  buffer[]);

    for ( i = 0; i < 3; ++i )
    {
        readLine (line);
        printf ("%s

", line);
    }

    return 0;
}

// Function to read a line of text from the terminal

void  readLine (char  buffer[])
{
    char  character;
    int   i = 0;

    do
    {
        character = getchar ();
        buffer[i] = character;
        ++i;
    }
    while ( character != '
' );

    buffer[i - 1] = '';
}

This is a sample line of text.
This is a sample line of text.

abcdefghijklmnopqrstuvwxyz
abcdefghijklmnopqrstuvwxyz

runtime library routines
runtime library routines

The do loop in the readLine function is used to build up the input line inside the character array buffer. Each character that is returned by the getchar function is stored in the next location of the array. When the newline character is reached—signaling the end of the line—the loop is exited. The null character is then stored inside the array to terminate the character string, replacing the newline character that was stored there the last time that the loop was executed. The index number i – 1 indexes the correct position in the array because the index number was incremented one extra time inside the loop the last time it was executed.

The main routine defines a character array called line with enough space reserved to hold 81 characters. This ensures that an entire line (80 characters has historically been used as the line length of a “standard terminal”) plus the null character can be stored inside the array. However, even in windows that display 80 or fewer characters per line, you are still in danger of overflowing the array if you continue typing past the end of the line without pressing the Enter (or Return) key. It is a good idea to extend the readLine function to accept as a second argument the size of the buffer. In this way, the function can ensure that the capacity of the buffer is not exceeded.

The program then enters a for loop, which simply calls the readLine function three times. Each time that this function is called, a new line of text is read from the terminal. This line is simply echoed back at the terminal to verify proper operation of the function. After the third line of text has been displayed, execution of Program 10.6 is then complete.

For your next program example (see Program 10.7), consider a practical text-processing application: counting the number of words in a portion of text. Develop a function called countWords, which takes as its argument a character string and which returns the number of words contained in that string. For the sake of simplicity, assume here that a word is defined as a sequence of one or more alphabetic characters. The function can scan the character string for the occurrence of the first alphabetic character and considers all subsequent characters up to the first nonalphabetic character as part of the same word. Then, the function can continue scanning the string for the next alphabetic character, which identifies the start of a new word.

//  Function to determine if a character is alphabetic

#include <stdio.h>
#include <stdbool.h>

bool alphabetic (const char  c)
{
    if  ( (c >= 'a'  &&  c <= 'z') || (c >= 'A'  &&  c <= 'Z') )
       return true;
    else
       return false;
}

/* Function to count the number of words in a string */

int  countWords (const char  string[])
{
    int   i, wordCount = 0;
    bool  lookingForWord = true, alphabetic (const char  c);

    for ( i = 0;  string[i] != '';  ++i )
        if ( alphabetic(string[i]) )
        {
            if ( lookingForWord )
            {
                ++wordCount;
                lookingForWord = false;
            }
        }
        else
            lookingForWord = true;
    return wordCount;
}

int main (void)
{
    const char  text1[] = "Well, here goes.";
    const char  text2[] = "And here we go... again.";
    int   countWords (const char  string[]);

    printf ("%s - words = %i
", text1, countWords (text1));
    printf ("%s - words = %i
", text2, countWords (text2));

    return 0;
}

Well, here goes. - words = 3
And here we go... again. - words = 5

The alphabetic function is straightforward enough—it simply tests the value of the character passed to it to determine if it is either a lowercase or uppercase letter. If it is either, the function returns true, indicating that the character is alphabetic; otherwise, the function returns false.

The countWords function is not as straightforward. The integer variable i is used as an index number to sequence through each character in the string. The integer variable lookingForWord is used as a flag to indicate whether you are currently in the process of looking for the start of a new word. At the beginning of the execution of the function, you obviously are looking for the start of a new word, so this flag is set to true. The local variable wordCount is used for the obvious purpose of counting the number of words in the character string.

For each character inside the character string, a call to the alphabetic function is made to determine whether the character is alphabetic. If the character is alphabetic, the lookingForWord flag is tested to determine if you are in the process of looking for a new word. If you are, the value of wordCount is incremented by 1, and the lookingForWord flag is set to false, indicating that you are no longer looking for the start of a new word.

If the character is alphabetic and the lookingForWord flag is false, this means that you are currently scanning inside a word. In such a case, the for loop is continued with the next character in the string.

If the character is not alphabetic—meaning either that you have reached the end of a word or that you have still not found the beginning of the next word—the flag lookingForWord is set to true (even though it might already be true).

When all of the characters inside the character string have been examined, the function returns the value of wordCount to indicate the number of words that were found in the character string.

It is helpful to present a table of the values of the various variables in the countWords function to see how the algorithm works. Table 10.1 shows such a table, with the first call to the countWords function from the preceding program as an example. The first line of Table 10.1 shows the initial value of the variables wordCount and lookingForWord before the for loop is entered. Subsequent lines depict the values of the indicated variables each time through the for loop. So, the second line of the table shows that the value of wordCount has been set to 1 and the lookingForWord flag set to false (0) after the first time through the loop (after the 'W' has been processed). The last line of the table shows the final values of the variables when the end of the string is reached. You should spend some time studying this table, verifying the values of the indicated variables against the logic of the countWords function. After this has been accomplished, you should then feel comfortable with the algorithm that is used by the function to count the number of words in a string.

Now consider a slightly more practical example of the use of the countWords function. This time, you make use of your readLine function to allow the user to type in multiple lines of text at the terminal window. The program then counts the total number of words in the text and displays the result.

To make the program more flexible, you do not limit or specify the number of lines of text that are entered. Therefore, you must have a way for the user to “tell” the program when he is done entering text. One way to do this is to have the user simply press the Enter (or Return) key an extra time after the last line of text has been entered. When the readLine function is called to read in such a line, the function immediately encounters the newline character and, as a result, stores the null character as the first (and only) character in the buffer. Your program can check for this special case and can know that the last line of text has been entered after a line containing no characters has been read.

A character string that contains no characters other than the null character has a special name in the C language; it is called the null string. When you think about it, the use of the null string is still perfectly consistent with all of the functions that you have defined so far in this chapter. The stringLength function correctly returns 0 as the size of the null string; your concat function also properly concatenates “nothing” onto the end of another string; even your equalStrings function works correctly if either or both strings are null (and in the latter case, the function correctly calls these strings equal).

Always remember that the null string does, in fact, have a character in it, albeit a null one.

Sometimes, it becomes desirable to set the value of a character string to the null string. In C, the null string is denoted by an adjacent pair of double quotation marks. So, the statement

char  buffer[100] = "";

defines a character array called buffer and sets its value to the null string. Note that the character string "" is not the same as the character string " " because the second string contains a single blank character. (If you are doubtful, send both strings to the equalStrings function and see what result comes back.)

Program 10.8 uses the readLine, alphabetic, and countWords functions from previous programs. They have not been shown in the program listing to conserve space.

#include <stdio.h>
#include <stdbool.h>

/*****  Insert alphabetic function here   *****/

/*****  Insert readLine function here    *****/

/*****  Insert countWords function here  *****/

int main (void)
{
    char  text[81];
    int   totalWords = 0;
    int   countWords (const char  string[]);
    void  readLine (char  buffer[]);
    bool  endOfText = false;

    printf ("Type in your text.
");
    printf ("When you are done, press 'RETURN'.

");

    while ( ! endOfText )
    {
        readLine (text);

        if ( text[0] == '' )
            endOfText = true;
        else
            totalWords += countWords (text);
    }

    printf ("
There are %i words in the above text.
",  totalWords);

    return 0;
}

Type in your text.
When you are done, press 'RETURN'.

Wendy glanced up at the ceiling where the mound of lasagna loomed
like a mottled mountain range. Within seconds, she was crowned with
ricotta ringlets and a tomato sauce tiara. Bits of beef formed meaty
moles on her forehead. After the second thud, her culinary coronation
was complete.
Enter
There are 48 words in the above text.

The line labeled Enter indicates the pressing of the Enter or Return key.

The endOfText variable is used as a flag to indicate when the end of the input text has been reached. The while loop is executed as long as this flag is false. Inside this loop, the program calls the readLine function to read a line of text. The if statement then tests the input line that is stored inside the text array to see if just the Enter (or Return) key was pressed. If so, then the buffer contains the null string, in which case the endOfText flag is set to true to signal that all of the text has been entered.

If the buffer does contain some text, the countWords function is called to count the number of words in the text array. The value that is returned by this function is added into the value of totalWords, which contains the cumulative number of words from all lines of text entered thus far.

After the while loop is exited, the program displays the value of totalWords, along with some informative text, at the terminal.

It might seem that the preceding program does not help to reduce your work efforts much because you still have to manually enter all of the text at the terminal. But as you will see in Chapter 16, “Input and Output Operations in C,” this same program can also be used to count the number of words contained in a file stored on a disk, for example. So, an author using a computer system for the preparation of a manuscript might find this program extremely valuable as it can be used to quickly determine the number of words contained in the manuscript (assuming the file is stored as a normal text file and not in some word processor format like Microsoft Word).

The method used by the lookup function to search for a particular word in the dictionary is straightforward enough; the function simply performs a sequential search through all the entries in the dictionary until either a match is made or the end of the dictionary is reached. For a small-sized dictionary like the one in your program, this approach is perfectly fine. However, if you start dealing with large dictionaries containing hundreds or perhaps even thousands of entries, this approach might no longer be sufficient because of the time it takes to sequentially search through all of the entries. The time required can be considerable—even though considerable in this case could mean only a fraction of a second. One of the prime considerations that must be given to any sort of information retrieval program is that of speed. Because the searching process is one that is so frequently used in computer applications, much attention has been given by computer scientists to developing efficient algorithms for searching (about as much attention as has been given to the process of sorting).

You can make use of the fact that your dictionary is in alphabetical order to develop a more efficient lookup function. The first obvious optimization that comes to mind is in the case that the word you are looking for does not exist in the dictionary. You can make your lookup function “intelligent” enough to recognize when it has gone too far in its search. For example, if you look up the word “active” in the dictionary defined in Program 10.9, as soon as you reach the word “acumen,” you can conclude that “active” is not there because, if it was, it would have appeared in the dictionary before the word “acumen.”

As was mentioned, the preceding optimization strategy does help to reduce your search time somewhat, but only when a particular word is not present in the dictionary. What you are really looking for is an algorithm that reduces the search time in most cases, not just in one particular case. Such an algorithm exists under the name of the binary search.

The strategy behind the binary search is relatively simple to understand. To illustrate how this algorithm works, take an analogous situation of a simple guessing game. Suppose I pick a number from 1 to 99 and then tell you to try to guess the number in the fewest number of guesses. For each guess that you make, I can tell you if you are too low, too high, or if your guess is correct. After a few tries at the game, you will probably realize that a good way to narrow in on the answer is by using a halving process. For example, if you take 50 as your first guess, an answer of either “too high” or “too low” narrows the possibilities down from 100 to 49. If the answer was “too high,” the number must be from 1 to 49, inclusive; if the answer was “too low,” the number must be from 51 to 99, inclusive.

You can now repeat the halving process with the remaining 49 numbers. So if the first answer was “too low,” the next guess should be halfway between 51 and 99, which is 75. This process can be continued until you finally narrow in on the answer. On the average, this procedure takes far less time to arrive at the answer than any other search method.

The preceding discussion describes precisely how the binary search algorithm works. The following provides a formal description of the algorithm. In this algorithm, you are looking for an element x inside an array M, which contains n elements. The algorithm assumes that the array M is sorted in ascending order.

compareStrings ("alpha", "altered")

compareStrings ("zioty", "yucca");

// Dictionary lookup program

#include <stdio.h>

struct  entry
{
    char  word[15];
    char  definition[50];
};

// Function to compare two character strings

int  compareStrings (const char  s1[], const char  s2[])
{
    int  i = 0, answer;

    while ( s1[i] == s2[i] && s1[i] != ''&& s2[i] != '' )
        ++i;

    if ( s1[i] < s2[i] )
        answer = -1;               /* s1 < s2  */
    else if ( s1[i] == s2[i] )
        answer = 0;                 /* s1 == s2 */
    else
        answer = 1;                 /* s1 > s2  */

    return answer;
}

// Function to look up a word inside a dictionary

int  lookup (const struct entry  dictionary[], const char  search[],
             const int  entries)
{
    int  low = 0;
    int  high = entries - 1;
    int  mid, result;
    int  compareStrings (const char  s1[], const char  s2[]);

    while  ( low <= high )
    {
        mid = (low + high) / 2;
        result = compareStrings (dictionary[mid].word, search);

        if ( result == -1 )
            low = mid + 1;
        else if ( result == 1 )
            high = mid - 1;
        else
            return mid;    /* found it */
     }

     return -1;            /* not found */
}

int main (void)
{
    const struct entry  dictionary[100] =
       { { "aardvark", "a burrowing African mammal"        },
         { "abyss",    "a bottomless pit"                  },
         { "acumen",   "mentally sharp; keen"              },
         { "addle",    "to become confused"                },
         { "aerie",    "a high nest"                       },
         { "affix",    "to append; attach"                 },
         { "agar",     "a jelly made from seaweed"         },
         { "ahoy",     "a nautical call of greeting"       },
         { "aigrette", "an ornamental cluster of feathers" },
         { "ajar",     "partially opened"                  } };
    int   entries = 10;
    char  word[15];
    int   entry;
    int   lookup (const struct entry  dictionary[], const char  search[],
                  const int  entries);

    printf ("Enter word: ");
    scanf ("%14s", word);

    entry = lookup (dictionary, word, entries);

    if ( entry != -1 )
        printf ("%s
", dictionary[entry].definition);
    else
        printf ("Sorry, the word %s is not in my dictionary.
", word);

    return 0;
}

Enter word: aigrette
an ornamental cluster of feathers

Enter word: acerb
Sorry, that word is not in my dictionary.