ADS

Structure In C Programming | C Programming

Structure In C Programming 

  Arrays are used to store large set of data and manipulate them but the disadvantage is that all the elements stored in an array are to be of the same data type. If we need to use a collection of different data type items it is not possible using an array. When we require using a collection of different data items of different data types we can use a structure.  Structure is a method of grouping data of different types.  A structure is a convenient method of handling a group of related data items of different data types.  



Structure declaration: 

General format:   
struct tag_name{          
data type member1;   
data type member2;   
…   
};
 Example:      
struct lib_books       
{ char title[20];   
char author[15];             
int pages;            
float price;         
};   
   
the keyword struct declares a structure to holds the details of four fields namely title, author pages and price. These are members of the structures. Each member may belong to different or same data type. The tag name can be used to define objects that have the tag names structure. The structure we just declared is not a variable by itself but a template for the structure. We can declare structure variables using the tag name anywhere in the program. For example the statement,                   
  
struct lib_books book1, book2, book3;    
 declares book1, book2, book3 as variables of type struct lib_books each declaration has four  elements of the structure lib_books. The complete structure declaration might look like this                     struct lib_books                   
{                           
char title[20];                           
char author[15];                         
int pages;                        
 float price;                   
};   
                  struct lib_books, book1, book2, book3;     

structures do not occupy any memory until it is associated with the structure variable such as book1. The template is terminated with a semicolon. While the entire declaration is considered as a statement, each member is declared independently for its name and type in a separate statement inside the template. The tag name such as lib_books can be used to declare structure variables of its data type later in the program. We can also combine both template declaration and variables declaration in one statement, the declaration             
struct lib_books           
{                   
char title[20];                   
char author[15];                   
int pages;                   
float price;             
} book1, book2, book3;       
is valid. The use of tag name is optional for example             
struct           
{                   
…                  
 …                   
…             
} book1, book2, book3;      

declares book1, book2, book3 as structure variables representing 3 books but does not include a    tag name for use in the declaration.       

A structure is usually defining before main along with macro definitions. In such cases the    structure assumes global status and all the functions can access the structure.     


  Giving values to members       

As mentioned earlier the members themselves are not variables they should be linked to    structure variables in order to make them meaningful members. The link between a member    and a variable is established using the member operator „. ‟ which is known as dot operator or    period operator.       For example:                    
 Book1.price       

Is the variable representing the price of book1 and can be treated like any other ordinary   variable. We can use scanf statement to assign values like                 
          scanf(“%s”,book1.file);   
          scanf(“%d”,& book1.pages);      

 Or we can assign variables to the members of book1                 

strcpy(book1.title,”basic”);                 
strcpy(book1.author,”Balagurusamy”);              
 book1.pages=250;               
book1.price=28.50;    

Assignment to Students      

Explain how to access array elements and to display those elements under two topics: (i)    Accessing array elements (ii) displaying array elements.  

Functions and structures       

We can pass structures as arguments to functions. Unlike array names however, which always    point to the start of the array, structure names are not pointers. As a result, when we change    structure parameter inside a function, we don‟t affects its corresponding argument.   


Passing structure to elements to functions     

A structure may be passed into a function as individual member or a separate variable.     A program example to display the contents of a structure passing the individual elements to a    function is shown below.              
 #include            
#include          
void fun(float,int);         
 void main()          
{                 
 struct student                  
{                        
float marks;                        
int id;            
};                  
struct student s1={67.5,14};                    
fun(s1.marks,s1.id);                  
getch();          }          
void fun(float marks,int id)          
{                     
printf("\nMarks:%f",marks);                    
printf("\nID:%d",id);          
}      

It can be realized that to pass individual elements would become more tedious as the number of structure elements go on increasing a better way would be to pass the entire structure variable    at a time.     


Passing entire structure to functions       

In case of structures having to having numerous structure elements passing these individual    elements would be a tedious task. In such cases we may pass whole structure to a function as    shown below:              
 # include stdio.h>           
{                   
int emp_id;                   
char name[25];                   
char department[10];                  
 float salary;           
};           
void main()           
{                   
static struct employee emp1= { 12, “sadanand”, “computer”, 7500.00 };                    
 /*sending entire employee structure*/                   
display(emp1);           
}               
/*function to pass entire structure variable*/             
display(empf)           
struct employee empf           
{                     
printf(“%d%s,%s,%f”, empf.empid,empf.name,empf.department,empf.salary);           
}     

  Arrays of structure      

It is possible to define an array of structures for example if we are maintaining information of all the students in the college and if 100 students are studying in the college. We need to use an array than single variables. We can define an array of structures as shown in the following example:             structure information           
{                   
int id_no;                   
char name[20];
 char address[20];                   
char combination[3]; 
int age;           
}            
 student[100];       

An array of structures can be assigned initial values just as any other array can. Remember that    each element is a structure that must be assigned corresponding initial values as illustrated  
  below.   
           
 #include< stdio.h >           
void main()          
{                   
struct info                   
{                        
 int id_no;                         
char name[20];                         
char address[20];                        
 char combination[3];                        
 int age;                   
};                  
struct info std[100];                   
int i,n;                     
printf(“Enter the number of students”);                   
scanf(“%d”,&n);                   
for(i=0;i < n;i++)                   
{                         
 printf(“ Enter Id_no,name address combination age\m”);                                scanf("%d%s%s%s%d”,&std[I].id_no,std[I].name,std[I].address,std[I].                           combination,&std[I].age);                  
}                   
printf(“\n Student information”);                   
for (I=0;I< n;I++)                   
{                         
 printf(“%d%s%s%s%d\n”,                              std[I].id_no,std[I].name,std[I].address,std[I].combination,std[I].age);                  
}          
}     

Structure within a structure       

A structure may be defined as a member of another structure. In such structures the declaration    of  the  embedded  structure  must  appear  before  the  declarations  of  other  structures.        struct date  int id_no;     
{  
char name[20];     
int day;  
char address[20];     
int month;  
char combination[3];     
int year;  int age;     
};  
structure date def;     
struct student  structure date doa;     
{  }oldstudent, newstudent;        

the structure student contains another structure date as its one of its members.   

Post a Comment

0 Comments