                      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 46









                      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.  Remember that the NULL is actually a "0" and  is
        added to the character string by the system.  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


                                  Page 47









                      Chapter 7 - Strings and Arrays


        string "Rosalinda", but 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 48









                      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  including  the  terminating   NULL.
        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 49









                      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 50









                      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  "large"  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 51
