Your Federal Quarterly Tax Payments are due April 15th Get Help Now >>

t15 BStructures Functions And Arrays by waheedanjum


									            Department of Computer and Information Science,
                       School of Science, IUPUI

CSCI 230

                 Functions and Arrays
             Dale Roberts, Lecturer
             Computer Science, IUPUI

                                  Dale Roberts
   Using Structures With Functions
Passing structures to functions
  Pass entire structure or pass individual members
  Both pass call by value
  It is not a good idea to pass a structure to or return from function.
  The better way is passing a pointer to the structure to the functions
  and returning a pointer from function.
To pass structures call-by-reference
  Pass its address
  Pass reference to it
To pass arrays call-by-value
  Create a structure with the array as a member
  Pass the structure

                            Dale Roberts
     Using Structures With Functions (cont.)
day_of_year(struct date *pd)
  int i, day, leap;

    day = pd -> day;
    leap = pd->year%4 ==0 && pd->year %100 ==0 || pd->year%400 ==0;
    for (i=1; i < pd -> month; i++)
       day += day_tab[leap][i];
    return (day);
         The declaration struct date *pd;
         says that pd is a pointer to a structure of the type date
         If p is a pointer to a structure, then p-> member_of_structure refers to the
         particular members, like pd -> year
          p-> member_of_structure is equivalent to (*p).member_of_structure
         Notice: ‘.’ has higher precedence than ‘*’; *pd.year is wrong, since pd.year
         is not a pointer.
         Both -> and . associate from left to right. So p -> q -> member
         are (p->q)->member.
         Example: emp.birthday.month are (emp.birthday).month

                                    Dale Roberts
  Using Structures With Functions (cont.)
  -> and . both are at the highest precedence (together with () for
 function and [] for array subscripts)

               struct {
                 int *x;
                 int *y;
               } *p;

++p->x;        is equivalent to ++(p->x) /* increment x, not p */
(++p)->x;      /* increment p before access x */
*p->y;         /* fetch whatever y points to */
*p->y++;       /* increments y after accessing whatever y point to */
(*p->y)++;     /* increments whatever y point to, just like *p->y++ */
*p++->y;       /* increments p after accessing whatever y point to */

                                Dale Roberts
      Creates synonyms (aliases) for previously defined data types
      Use typedef to create shorter type names
            typedef struct card *CardPtr;
      Defines a new type name CardPtr as a synonym for type struct card *
      typedef does not create a new data type while it only creates an alias
Example:   struct card {
              const char *face;
              const char *suit;
           typedef struct card Card;
           void fillDeck( Card * const, const char *[], const char *[] );
           int main()
              Card deck[ 52 ];
              const char *face[] = {"Ace", "Deuce", "Three", "Four", "Five", "Six",
                               Seven", "Eight", “Nine", "Ten", "Jack", "Queen", "King"};
              const char *suit[] = { "Hearts", "Diamonds", "Clubs", "Spades"};
                           .. ..
              fillDeck( deck, face, suit );
                           .. ..
           void fillDeck(Card * const wDeck, const char * wFace[], const char * wSuit[])
           .. ..
                                    Dale Roberts
                          Array of Structures
Example: (before)                                             struct person_data{
    char name[PERSON][NAMESIZE];                                  char name[NAMESIZE];
    int tscore[PERSON]                                            int tscore;
    int math[PERSON]                          (now)               int math;
    int english[PERSON]                                          int english;
                                                              } person[PERSON];
       Initialization of structure array
    struct person_data{
        .. .. .. ..                               the inner brace is not necessary
       } person[]={
                                                 “Jane”,180,89,91,
            .. .. .. ..                           .. .. .. ..
          }; /* similar to 2D array */

Example: using separated arrays                       Example: using pointer to structure

average (int tscore, int math, int                    average (struct person_data
   eng, int n)                                                 *person, int n)
   {                                                  {
     int i, total=0,mathtotal = 0,                    int i, total=0,mathtotal = 0,
     engtotal=0;                                      engtotal=0;
     for (i=0; i<n, i++) {                                for (i=0; i<n, i++) {
         total += *tscore++;                                   total += person->tscore;
         mathtotal += *math++;                                 mathtotal += person->math;
         engtotal += *eng++;                                   engtotal += person->eng;
     }                                                         person++;
                                           Dale Roberts
  Memory that contains a variety of objects over time
  Only contains one data member at a time
  Members of a union share space
  Conserves storage
  Only the last data member defined can be accessed
union declarations
  Same as struct
        union Number {
           int x;
           float y;
        union Number value;
Valid union operations
  Assignment to union of same type: =
  Taking address: &
  Accessing union members: .
  Accessing members using pointers: ->

                         Dale Roberts
 1   /* Fig. 10.5: fig10_05.c
 2      An example of a union */
 3   #include <stdio.h>
 5   union number {
                                                        Define union
 6      int x;
 7      double y;
 8   };
10   int main()
11   {
12      union number value;                             Initialize variables
                                                        Set variables
14       value.x = 100;
15       printf( "%s\n%s\n%s%d\n%s%f\n\n",              Print
16              "Put a value in the integer member",
17              "and print both members.",
18              "int:   ", value.x,
                                                         Program Output
19              "double:\n", value.y );                    Put a value in the integer member
20                                                         and print both members.
                                                           int:    100
21       value.y = 100.0;
22       printf( "%s\n%s\n%s%d\n%s%f\n",                   -
23              "Put a value in the floating member",      9255959211743313600000000000000000000000000
24              "and print both members.",                 0000000000000000000.00000
25              "int:   ", value.x,
                                                           Put a value in the floating member
26              "double:\n", value.y );
                                                           and print both members.
27       return 0;                                         int:    0
28   }                                                     double:

                                           Dale Roberts
                                Bit Fields
Bit field
   Member of a structure whose size (in bits) has been specified
   Enable better memory utilization
   Must be declared as int or unsigned
   Cannot access individual bits

Declaring bit fields
   Follow unsigned or int member with a colon (:) and an integer constant representing
   the width of the field

          struct BitCard {
             unsigned face : 4;
             unsigned suit : 2;
             unsigned color : 1;
          };                                             struct Example {
                                                            unsigned a : 13;
Unnamed bit field                                           unsigned   : 3;
   Field used as padding in the structure                   unsigned b : 4;
   Nothing may be stored in the bits
   Unnamed bit field with zero width aligns next bit field to a new storage unit boundary

                                   Dale Roberts
            Enumeration Constants
  Set of integer constants represented by identifiers
  Enumeration constants are like symbolic constants whose values are
  automatically set
      Values start at 0 and are incremented by 1
      Values can be set explicitly with =
      Need unique constant names
            enum Months { JAN = 1, FEB, MAR, APR, MAY, JUN, JUL,
                           AUG, SEP, OCT, NOV, DEC};
      Creates a new type enum Months in which the identifiers are set to the
      integers 1 to 12
  Enumeration variables can only assume their enumeration constant
  values (not the integer representations)

                              Dale Roberts
1    /* Fig. 10.18: fig10_18.c
2        Using an enumeration type */
3    #include <stdio.h>
5    enum months { JAN = 1, FEB, MAR, APR, MAY, JUN,
6                    JUL, AUG, SEP, OCT, NOV, DEC };
8    int main()
9    {
10       enum months month;
11       const char *monthName[] = { "", "January", "February",
12                                      "March", "April", "May",     1     January
13                                      "June", "July", "August",    2    February
                                                                     3       March
14                                      "September", "October",      4       April
15                                      "November", "December" };    5         May
16                                                                   6        June
                                                                     7        July
17       for ( month = JAN; month <= DEC; month++ )                  8      August
18          printf( "%2d%11s\n", month, monthName[ month ] );        9   September
19                                                                  10     October
                                                                    11    November
20       return 0;                                                  12    December
21 }

                                            Dale Roberts
              Storage Management
C supports 4 functions, malloc(), calloc(),free(),
and cfree() for storage management
      allocate a node while its content is still ‘garbage’
      n is an integer, indicating the size of memory in byte which you would like
      to allocate
      malloc() return a character pointer to that memory
      So, you have to use cast operator (type), to change the type of the
            int *ip;
            ip = (int*) malloc(sizeof(int));
            struct treeNode *tp;
            tp = (struct tnode *) malloc(sizeof(struct tnode));

                              Dale Roberts
           Storage Management (cont.)
  free() will release the memory allocated by malloc().
  p is the pointer containing the address returning from malloc().
              int *ip;
              ip = (int*) malloc(sizeof(int));
              ... .. ..
              free(ip);      /* Question: can you free(ip) after ip++ ? */

              struct treeNode *tp;
              tp=(struct treeNode *)malloc(sizeof(struct treeNode ));
                     ... .. ..
  When there is no further memory, malloc() will return NULL pointer. It is a
  good idea to check the returning value of malloc().
   if ((ip=(int *)malloc(sizeof(int))) == NULL){
       printf(“\nMemory is FULL\n”);
  When you free the memory, you must be sure that you pass the original
  address returning from malloc() to function free(). Otherwise, system
  exception may be happened
                             Dale Roberts
           Storage Management (cont.)
  calloc() allow you to allocate an n elements array of same data type.
  Because n can be an integer variable, you can use calloc() to allocate a
  dynamic size array.
  n is the element number of array that you want to allocate.
  size is the number of byte of each element.
  Unlike malloc(), calloc() guarantees that memory contents are all zero
Example: allocate an array of 10 elements
              int *ip;
              ip = (int*) calloc(10, sizeof(int));

   *(ip+1) refer to the 2nd element, the same as ip[1]
   *(ip+i) refer to the i+1th element, the same as ip[i]
  Like malloc(), calloc() will return NULL, if no further memory is available.
   cfree() releases the memory allocated by calloc().
                              Dale Roberts

To top