Initialization of Variables

Initialization of Variables:

An external variable might be initialized at the compile time by following its name with an initializing value whenever it is defined. The initializing value has to be somewhat whose value is recognized at compile time, such as a constant.

int     x  =     0;      /* "0" could be any constant */
int     *p      &y[1];  /* p now points to y[1] */

External array can be initialized by following its name with the list of initializations included in braces: 

       int     x[4] =    {0,1,2,3};  /* makes x[i] = i */
       int     y[ ]  =  {0,1,2,3};  /* makes y big enough for 4 values */
       char    *msg  =  "syntax error\n";   /* braces unnecessary here */
       char *keyword[ ]={
               "if",
               "else",
               "for",
               "while",
               "break",
               "continue",
               0
       };

The last one is very helpful; it makes keyword an array of pointers to the character strings, with a zero at the end therefore we can recognize the last element very easily. A simple lookup routine could scan this till it either determine a match or encounters a zero keyword pointer: 

   lookup(str)            
/* search for str in keyword[ ] */
      char *str; {
           int i,j,r;
           for( i=0; keyword[i] != 0; i++) {
                   for( j=0; (r=keyword[i][j]) == str[j] && r != '\0'; j++
);
                   if( r == str[j] )
                           return(i);
           }
           return(-1);
   }


Scope Rules:

A complete C program require not be compiled all at once; source text of the program might be kept in some files, and formerly compiled routines might be loaded from libraries. How do we organize that data gets passed from one routine to the other?

Warning: the words declaration and definition are employed accurately in this section; do not treat them as similar thing.

The major shortcut exists for forming extern declarations. If the definition of a variable appears prior to its use in several function, no extern declaration is required within the function. Therefore, when a file comprises: 

       f1( ) { ... }
       int foo;
       f2( ) { ... foo = 1; ... } 
       f3( ) { ... if ( foo ) ... }

No declaration of foo is required in either f2 or f3, since the external definition of foo emerges prior to them. However when f1 wants to utilize foo, it has to include the declaration

       f1( ) {
               extern int foo;
               ...
       }

This is true as well of any function which exists on the other file; if it desires foo it has to employ an extern declaration for it. (When somewhere, there is an extern declaration for something, there should also ultimately be an external definition of it, or you will get an `undefined symbol' message.)

There are various hidden pitfalls in an external declarations and definitions when you use multiple source files. To avoid them, initially, define and initialize each external variable just once in the whole set of files:

int     foo  =   0;

You can get away with the multiple external definitions on UNIX, however not on GCOS; therefore do not ask for trouble. Multiple initializations are unlawful everywhere. Secondly, at the starting of any file which contains functions require a variable whose definition is in some other file, put in an extern declaration, exterior of any function:  

extern  int     foo;
       f1( ) { ... }           etc.


#define, #include:

C gives a very limited macro facility. You can state,

#define name            something

and afterward anywhere `name' appears as a token, `something' will be replaced. This is mainly helpful in parametering the sizes of arrays: 

       #define ARRAYSIZE       100
               int     arr[ARRAYSIZE];
                ...
               while( i++ < ARRAYSIZE )..
.

(Now we can modify the whole program by changing only the define) or in setting up the mysterious constants: 

       #define SET             01
       #define INTERRUPT       02    
 /* interrupt bit */
       #define ENABLED 04
        ...
       if( x & (SET | INTERRUPT | ENABLED) ) ...
 

Now we contain meaningful words rather than mysterious constants. It is an excellent practice to write programs devoid of any literal constants except for in #define statements.  There are some warnings about #define. Initially, there is no semicolon at the end of #defines; all the text from name to the end of the line (apart from comments) is taken to be `something'. Whenever it is put into the text, blanks are positioned around it. The other control word recognized to C is #include. To include one file in your source at compilation time, state:

#include "filename"

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.