                      Chapter 7 - Strings and Arrays


                             WHAT IS A STRING?

             A  string is a group of characters,  usually letters of 

        the  alphabet.   In order to format your printout in such  a 

        way that it looks nice, has meaningful titles and names, and 

        is  esthetically  pleasing to you and the people  using  the 

        output of your program,  you need the ability to output text 

        data.  Actually you have already been using strings, because 

        the second program in this tutorial,  way back in Chapter 2, 

        output a message that was handled internally as a string.  A 

        complete  definition  is  a  series  of  "char"  type   data 

        terminated by a NULL character, which is a zero. 

             When  C  is going to use a string of data in some  way, 

        either  to compare it with another,  output it,  copy it  to 

        another string,  or whatever, the functions are set up to do 

        what they are called to do until a NULL, which is a zero, is 

        detected. 

                             WHAT IS AN ARRAY?

             An array is a series of homogeneous pieces of data that 

        are all identical in type, but the type can be quite complex 

        as  we will see when we get to the chapter of this  tutorial 

        discussing structures.  A string is simply a special case of 

        an array. 

             The  best way to see these principles is by use  of  an 

        example,  so  load  the program CHRSTRG.C and display it  on 

        your monitor.   The first thing new is the line that defines 

        a "char" type of data entity.  The square brackets define an 

        array subscript in C, and in the case of the data definition 

        statement,  the  5 in the brackets defines 5 data fields  of 

        type  "char" all defined as the variable "name".   In the  C 

        language,  all subscripts start at 0 and increase by 1  each 

        step  up  to  the  maximum which in  this  case  is  4.   We 

        therefore  have  5 "char" type variables  named,  "name[0]", 

        "name[1]",  "name[2]",  "name[3]",  and "name[4]".  You must 

        keep in mind that in C, the subscripts actually go from 0 to 

        one   less  than  the  number  defined  in  the   definition 

        statement. 

                         HOW DO WE USE THE STRING?

             The  variable  "name" is therefore a string  which  can 

        hold up to 5 characters, but since we need room for the NULL 

        character,  there are actually only four useful  characters.  

        To  load  something  useful  into  the  string,  we  have  5 

        statements, each of which assigns one alphabetical character 

        to one of the string characters.  Finally, the last place in 

        the string is filled with the numeral 0 as the end indicator 



                                  Page 42









                      Chapter 7 - Strings and Arrays


        and  the string is complete.   (A "define" would allow us to 

        use "NULL" instead of a zero,  and this would add greatly to 

        the  clarity of the program.  It would be very obvious  that 

        this  was  a  NULL  and not simply a  zero  for  some  other 

        purpose.) Now that we have the string,  we will simply print 

        it out with some other string data in the output statement. 

             The %s is the output definition to output a string  and 

        the  system  will output characters starting with the  first 

        one in "name" until it comes to the NULL character,  and  it 

        will quit.   Notice that in the "printf" statement, only the 

        variable  name "name" needs to be given,  with no  subscript 

        since  we  are  interested  in starting  at  the  beginning.  

        (There  is  actually another reason that only  the  variable 

        name  is  given without brackets.   The discussion  of  that 

        topic will be given in the next chapter.)

                        OUTPUTTING PART OF A STRING

             The  next "printf" illustrates that we can  output  any 

        single  character of the string by using the "%c" and naming 

        the particular character of "name" we want by including  the 

        subscript.   The last "printf" illustrates how we can output 

        part  of the string by stating the starting point by using a 

        subscript.   The & specifies the address of  "name[1]".   We 

        will  study this in the next chapter but I thought you would 

        benefit from a little glimpse ahead.

             This example may make you feel that strings are  rather 

        cumbersome  to  use since you have to set up each  character 

        one  at  a time.   That is an incorrect  conclusion  because 

        strings  are  very easy to use as we will see  in  the  next 

        example program. 

             Compile and run this program.

                          SOME STRING SUBROUTINES

             Load  the  example program STRINGS.C for an example  of 

        some  ways  to use strings.  First we define  four  strings.  

        Next  we  come  to a new function that you  will  find  very 

        useful,  the "strcpy" function,  or string copy.   It copies 

        from  one  string  to another until it  comes  to  the  NULL 

        character.   It is easy to remember which one gets copied to 

        which  if  you think of them like an  assignment  statement.  

        Thus if you were to say, for example, "x = 23;", the data is 

        copied  from  the  right entity to the  left  one.   In  the 

        "strcpy"  function,  the data is also copied from the  right 

        entity  to  the left,  so that after execution of the  first 

        statement,  name1 will contain the string  "Rosalinda",  but 





                                  Page 43









                      Chapter 7 - Strings and Arrays


        without  the double quotes,  they are the compiler's way  of 

        knowing that you are defining a string.

             Likewise,  "Zeke"  is copied into "name2" by the second 

        statement,  then the "title" is copied.   The title and both 

        names are then printed out.   Note that it is not  necessary 

        for  the  defined string to be exactly the same size as  the 

        string it will be called upon to store,  only that it is  at 

        least  as long as the string plus one more character for the 

        NULL. 

                      ALPHABETICAL SORTING OF STRINGS

             The  next function we will look at is the  "strcmp"  or 

        the  string  compare function.   It will return a 1  if  the 

        first string is larger than the second, zero if they are the 

        same  length  and have the same characters,  and -1  if  the 

        first  string  is  smaller  than the  second.   One  of  the 

        strings,  depending  on the result of the compare is  copied 

        into   the   variable  "mixed",   and   the   largest   name 

        alphabetically  is  printed  out.   It  should  come  as  no 

        surprise   to   you   that  "Zeke"  wins   because   it   is 

        alphabetically  larger,  length  doesn't  matter,  only  the 

        alphabet.  It might be wise to mention that the result would 

        also depend on whether the letters were upper or lower case.  

        There are functions available with your C compiler to change 

        the  case of a string to all upper or all lower case if  you 

        desire.   These  will be used in an example program later in 

        this tutorial.

                             COMBINING STRINGS

             The last four statements have another new feature,  the 

        "strcat",  or string concatenation function.   This function 

        simply  adds the characters from one string onto the end  of 

        another string taking care to adjust the NULL so  everything 

        is  still all right.   In this case,  "name1" is copied into 

        "mixed",  then two blanks are concatenated to  "mixed",  and 

        finally  "name2"  is concatenated to the  combination.   The 

        result  is printed out with both names in the  one  variable 

        "mixed". 

             Strings  are  not difficult and are  extremely  useful.  

        You should spend some time getting familiar with them before 

        proceeding on to the next topic.

             Compile  and run this program and observe  the  results 

        for compliance with this definition.






                                  Page 44









                      Chapter 7 - Strings and Arrays


                            AN ARRAY OF INTEGERS

             Load the file INTARRAY.C and display it on your monitor 

        for  an  example of an array of integers.   Notice that  the 

        array is defined in much the same way we defined an array of 

        char  in  order to do the string manipulations in  the  last 

        section.   We  have  12 integer variables to work  with  not 

        counting the one named "index".   The names of the variables 

        are "values[0]",  "values[1]", ... , and "values[11]".  Next 

        we have a loop to assign nonsense, but well defined, data to 

        each of the 12 variables,  then print all 12 out. You should 

        have  no  trouble following this program,  but be  sure  you 

        understand  it.   Compile and run it to see if it does  what 

        you expect it to do.

                      AN ARRAY OF FLOATING POINT DATA

             Load  and display the program named BIGARRAY.C  for  an 

        example  of  a program with an array of "float"  type  data.  

        This  program has an extra feature to illustrate how strings 

        can  be  initialized.    The  first  line  of  the   program 

        illustrates to you how to initialize a string of characters.  

        Notice  that the square brackets are empty leaving it up  to 

        the  compiler  to count the characters and  allocate  enough 

        space for our string.   Another string is initialized in the 

        body  of the program but it must be declared "static"  here.  

        This  prevents  it  from being allocated as  an  "automatic" 

        variable and allows it to retain the string once the program 

        is started.   There is nothing else new here,  the variables 

        are  assigned  nonsense  data and the  results  of  all  the 

        nonsense are printed out along with a header.   This program 

        should also be easy for you to follow, so study it until you 

        are  sure  of what it is doing before going on to  the  next 

        topic.

                     GETTING DATA BACK FROM A FUNCTION

             Back  in chapter 5 when we studied functions,  I hinted 

        to you that there was a way to get data back from a function 

        by  using  an array,  and that is true.   Load  the  program 

        PASSBACK.C for an example of doing that.   In this  program, 

        we  define  an array of 20 variables  named  "matrix",  then 

        assign  some nonsense data to the variables,  and print  out 

        the  first five.   Then we call the function "dosome" taking 

        along  the entire array by putting the name of the array  in 

        the parentheses.

             The  function  "dosome" has a name in  its  parentheses 

        also but it prefers to call the array "list".   The function 

        needs  to be told that it is really getting an array  passed 

        to  it and that the array is of type "int".   The  following 



                                  Page 45









                      Chapter 7 - Strings and Arrays


        line,  prior to the bracket which starts the  program,  does 

        that  by  defining  "list" as an integer type  variable  and 

        including the square brackets to indicate an array.   It  is 

        not  necessary to tell the function how many elements are in 

        the  array,  but you could if you so desired.   Generally  a 

        function  works with an array until some end-of-data  marker 

        is  found,  such  as  a NULL for a  string,  or  some  other 

        previously  defined data or pattern.   Many  times,  another 

        piece of data is passed to the function with a count of  how 


        many elements to work with.  In our present illustration, we 

        will use a fixed number of elements to keep it simple.

             So far nothing is different from the previous functions 

        we  have called except that we have passed more data  points 

        to  the function this time than we ever have before,  having 

        passed 20 integer values.  We print out the first 5 again to 

        see if they did indeed get passed here.   Then we add ten to 

        each of the elements and print out the new values.   Finally 

        we return to the main program and print out the same 5  data 

        points.   We  find that we have indeed modified the data  in 

        the function,  and when we returned to the main program,  we 

        brought  the changes back.   Compile and run this program to 

        verify this conclusion.

                         ARRAYS PASS DATA BOTH WAYS

             We  stated during our study of functions that  when  we 

        passed data to a function,  the system made a copy to use in 

        the  function which was thrown away when we returned.   This 

        is not the case with arrays.   The actual array is passed to 

        the  function  and  the function can modify it  any  way  it 

        wishes  to.    The  result  of  the  modifications  will  be 

        available  back  in  the calling  program.   This  may  seem 

        strange  to  you that arrays are  handled  differently  from 

        single point data, but they are.  It really does make sense, 

        but  you  will  have  to wait until we get  to  pointers  to 

        understand it. 

                         A HINT AT A FUTURE LESSON

             Another way of getting data back from a function to the 

        calling program is by using pointers which we will cover  in 

        the  next chapter.   When we get there we will find that  an 

        array  is in reality a pointer to a list of  values.   Don't 

        let  that  worry  you now,  it will make sense when  we  get 

        there.  In the meantime concentrate on arrays and understand 

        the  basics  of  them because when we get to  the  study  of 

        structures  we will be able to define some pretty  elaborate 

        arrays.




                                  Page 46









                      Chapter 7 - Strings and Arrays


                        MULTIPLY DIMENSIONED ARRAYS

             Load  and  display  the file named  MULTIARY.C  for  an 

        example  of a program with doubly dimensioned  arrays.   The 

        variable "big" is an 8 by 8 array that contains 8 times 8 or 

        64 elements total.   The first element is  "big[0][0]",  and 

        the last is "big[7][7]".  Another array named "huge" is also 

        defined  which  is not square to illustrate that  the  array 

        need  not  be square.   Both are filled up  with  data,  one 


        representing  a  multiplication  table and the  other  being 

        formed into an addition table. 

             To illustrate that individual elements can be  modified 

        at will,  one of the elements of "big" is assigned the value 

        from one of the elements of "huge" after being multiplied by 

        22.   Next "big[2][2]" is assigned the arbitrary value of 5, 

        and  this  value  is  used for the subscripts  of  the  next 

        assignment statement.   The third assignment statement is in 

        reality  "big[5][5]  = 177" because each of  the  subscripts 

        contain the value 5.   This is only done to illustrate  that 

        any  valid expression can be used for a subscript.   It must 

        only meet two conditions,  it must be an integer (although a 

        "char"  will work just as well),  and it must be within  the 

        range of the subscript it is being used for.

             The  entire matrix variable "big" is printed out  in  a 

        square  form so you can check the values to see if they  did 

        get set the way you expected them to.

        PROGRAMMING EXERCISES

        1.   Write  a  program with  three short  strings,  about  6 

             characters each, and use "strcpy" to copy "one", "two", 

             and  "three" into them.  Concatenate the three  strings 

             into one string and print the result out 10 times.

        2.   Define  two  integer  arrays,  each 10  elements  long, 

             called "array1" and "array2".  Using a loop,  put some 

             kind  of  nonsense data in each and add them  term  for 

             term  into  another 10 element  array  named  "arrays". 

             Finally,  print  all  results in a table with an  index 

             number.
             1     2 +  10 =  12
             2     4 +  20 =  24
             3     6 +  30 =  36   etc.

             Hint; The print statement will be similar to;
                printf("%4d %4d + %4d = %4d\n",index,array1[index],
                        array2[index],arrays[index]);



                                  Page 47

