Structures:

The key use of structures is to lump altogether collections of disparate variable types; therefore they can suitably be treated as a unit. For illustration, if we were writing a compiler or assembler, we might require for each identifier information such as its name (that is, a character array), its source line number (that is, an integer), some kind of information (that is, a character, perhaps), and possibly a usage count (that is, another integer).

char    id[10];
int     line;
char    type;
int     usage;

We can build a structure out of this quite simply. We initially tell C what the structure will look like, that is, what type of things it comprises; after that we can really reserve storage for it, either in similar statement or separately. The simplest thing is to define it and assign storage all at once: 

       struct {
               char    id[10];
               int     line;
               char    type;
               int     usage;       } sym;

This defines sym to be a structure with specified shape; line, id, type and usage are members of the structure. The way we refer to any specific member of the structure is:

structure-name . member
as in 
sym.type = 077;
if( sym.usage == 0 ) ...
while( sym.id[j++] ) ...
etc.

Though the names of structure members never stand only, they still encompass to be unique; there can't be other id or usage in some other structure. So far we have not gained much. The benefits of structures begin to come whenever we have arrays of structures, or whenever we want to pass complicated data layouts among functions.

Assume that, we wanted to form a symbol table for up to 100 identifiers. We could extend our definitions like:

char    id[100][10];
int     line[100];
char    type[100];
int     usage[100];

However a structure lets us re-arrange this spread-out information therefore all the data regarding a single identifier is collected to one lump:    

   struct {
               char    id[10];
               int     line;
               char    type;
               int     usage;
          } sym[100];

This form sym an array of structures; each array element has a particular shape. Now we can refer to members as:

    sym[i].usage++; /* increment usage of i-th identifier */
            for( j=0; sym[i].id[j++] != '\0'; ) ...
                  etc.

Therefore to print a list of all identifiers that hasn’t been employed, altogether with their line number,            

 for( i=0; i<nsym; i++ )
                    if( sym[i].usage == 0 )
                            printf("%d\t%s\n", sym[i].line, sym[i].id);

Assume that we now desire to write a function lookup(name) that will tell us when name already exists in sym, by giving its index, or that it does not, by returning a -1. We cannot pass a structure to a function directly; we have to either define it outwardly, or pass a pointer to it.

Let us try the first method first. 

       int     nsym    0;      /* current length of symbol table */
 
       struct {
               char    id[10];
               int     line;
               char    type;
               int     usage;
       } sym[100];             /* symbol table */
main( ) {
               ...
               if( (index = lookup(newname)) >= 0 )
                       sym[index].usage++;        /* already there ... */
               else
                       install(newname, newline, newtype);
               ...
       }
 
       lookup(s)
          char *s; {
               int i;
               extern struct {
                       char    id[10];
                       int     line;
                       char    type;
                       int     usage;
               } sym[ ];
 
               for( i=0; i<nsym; i++ )
                       if( compar(s, sym[i].id) > 0 )
                               return(i);
               return(-1);
       }
 
       compar(s1,s2)           /*  return 1 if s1==s2, 0 otherwise */
          char *s1, *s2; {
               while( *s1++ == *s2 )
                       if( *s2++ == '\0' )
                               return(1);
               return(0);
       }

The declaration of structure in lookup is not required if the external definition precedes its utilization in similar source file, as we shall see in a moment.

Now what if we wish for to use pointers? 

       struct  symtag {
               char    id[10];
               int     line;
               char    type;
               int     usage;
       } sym[100], *psym;
               psym = &sym[0]; /* or p = sym; */
 
This forms psym a pointer to our type of structure (that is, the symbol table), then initializes it to point to the initial element of sym.

Note that we added something subsequent to the word struct: a `tag' termed symtag. This place a name on our structure definition therefore we can refer to it later with no repeating the definition.

It is not essential however helpful. However we could have state: 

       struct  symtag {
               ... structure definition
       };

Which would not have assigned any storage at all, and then state: 

       struct  symtag  sym[100];
       struct  symtag  *psym;

This would define the array and pointer. This could be condensed additional, to 

      struct  symtag  sym[100], *psym;

The way we really refer to a member of the structure by a pointer is like: 

               ptr -> structure-member

The symbol `->' signifies we are pointing at a member of a structure; `->' is only employed in that context. ptr is a pointer to the base of a structure which comprises the structure member. The expression ptr->structure-member refers to indicated member of pointed-to structure.  Therefore we encompass constructions like: 

       psym->type = 1;
       psym->id[0] = 'a';

For more complex pointer expressions, it is wise to employ parentheses to make it clear who goes with what.  For illustration, 

       struct { int x, *y; } *p;
       p->x++  increments x
       ++p->x  so does this!
       (++p)->x         increments p before getting x
       *p->y++         employs y as a pointer, then increments it
       *(p->y)++       so does this
       *(p++)->y       employs y as a pointer, then increments p

The manner to remember these is that ->, . (dot), ( ) and [ ] join very tightly. An expression comprising one of such is treated as a unit.  p->x, a[i], y.x and f(b) are names precisely as abc is.

When p is a pointer to a structure, any arithmetic on p takes into account the actual size of the structure. For example p++ increases p by the accurate amount to get the subsequent element of the array of structures. However do not suppose that the size of a structure is the sum of sizes of its members -- since of alignments of various sized objects, there might be `holes' in a structure.

Here is the lookup illustration, with pointers. 

       struct symtag {
               char    id[10];
               int     line;
               char    type;
               int     usage;
       } sym[100];
 
       main( ) {
               struct symtag *lookup( );
               struct symtag *psym;
               ...
               if( (psym = lookup(newname)) )  /* non-zero pointer */
               psym -> usage++;                 /* means already  there */
               else
                       install(newname, newline, newtype);
               ...
       }
       struct symtag *lookup(s)
          char *s; {
               struct symtag *p;
               for( p=sym; p < &sym[nsym]; p++ )
                       if( compar(s, p->id) > 0)
                               return(p);
               return(0);
       }
 
The function ‘compar’ doesn't modify: `p->id' refers to a string.

In main, we test the pointer returned by lookup against zero, relying on the fact which a pointer is by definition never zero (0) whenever it really points at something. The other pointer operations are trivial.

The single complexity is the set of lines like:

       struct symtag *lookup( );

This brings us to a region that we will treat just hurriedly; the question of function types. Therefore far, all of our functions encompass returned integers (or characters that are much similar). What do we do whenever the function returns something else, similar to a pointer to a structure? The rule is that any function that does not return an int has to state explicitly what it does return. The type information goes prior to the function name (that can make the name hard to see).

Illustration: 

       char f(a)
          int a; {
               ...
       }
       int *g( ) { ... }
 
       struct symtag *lookup(s) char *s; { ... }
 
Function g returns a pointer to an integer, f returns a character, and lookup returns a pointer to a structure that looks like symtag. And if we are going to use one of such functions, we have to make a declaration where we employ it, as we did in main above.

Note the parallelism among the declarations:

struct symtag *lookup( );
struct symtag *psym;

In result, this states that lookup( ) and psym are both employed in similar way - as a pointer to a structure -- even although one is a variable and the other is function.

Latest technology based Programming Languages Online Tutoring Assistance

Tutors, at the www.tutorsglobe.com, take pledge to provide full satisfaction and assurance in Programming Languages help via online tutoring. Students are getting 100% satisfaction by online tutors across the globe. Here you can get homework help for Programming Languages, project ideas and tutorials. We provide email based Programming Languages help. You can join us to ask queries 24x7 with live, experienced and qualified online tutors specialized in Programming Languages. Through Online Tutoring, you would be able to complete your homework or assignments at your home. Tutors at the TutorsGlobe are committed to provide the best quality online tutoring assistance for Programming Languages Homework help and assignment help services. They use their experience, as they have solved thousands of the Programming Languages assignments, which may help you to solve your complex issues of Programming Languages. TutorsGlobe assure for the best quality compliance to your homework. Compromise with quality is not in our dictionary. If we feel that we are not able to provide the homework help as per the deadline or given instruction by the student, we refund the money of the student without any delay.