Вы находитесь на странице: 1из 10

Module 5

A Structure is a collection of related data items, possibly of different types or structure is


a collection of one or more variables, possibly of different types, grouped together under a
single name for convenient handling. A structure is heterogeneous in that it can be composed
of data of different types. In contrast, array is homogeneous since it can contain only data of
the same type.
Structures help to organize complicated data, particularly in large programs, because they
permit a group of related variables to be treated as a unit instead of as separate entities.
Structures are used to represent a record.
Defining a Structure
To define a structure, keyword struct is used. The struct statement defines a new data type, with
more than one member. The format of the struct statement is as follows
struct [structure tag]
{
member definition;
member definition;
...
member definition;
} [one or more structure variables];
The structure tag is the name given to structure which is optional and each member definition is
a normal variable definition, such as int i; or float f; or any other valid variable definition. At the
end of the structure's definition, before the final semicolon, we can specify one or more structure
variables but it is optional.
Eg. Declaration of Book structure with the following attributes about each book
Title
Author
Subject
Book ID
struct Books
{
char title[50];
char author[50];
char subject[100];
int book_id;
} book;
Notes: The template is terminated with semicolon
While the entire definition 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 can be used to declare structure variables of its type, later in program

Array Vs Structures
Array is collection of releated data elements of same type.structure can have elements of
different types
Array is derived data type whereas structure is a programmer-defined one
Array behaves like a built in data type. But in structure first we have to design and
declare a data structure before the variables of that type are declared and used
Declaration of structure variable
Structure variable declaration includes
1. The keyword struct
2. Structure tag name
3. List of variable names separated by commas
4. Terminating semicolon
Different Ways of Declaring Structure Variable :
Way 1 : Immediately after Structure Template
struct date
{
int date;
char month[20];
int year;
}today;
// 'today' is name of Structure variable
Way 2 : Declare Variables using struct Keyword
struct date
{
int date;
char month[20];
int year;
};
struct date today;

where date is name of structure and today is name of variable.


Way 3 : Declaring Multiple Structure Variables
struct Book
{
int pages;
char name[20];
int year;
}book1,book2,book3;
We can declare multiple variables separated by comma directly after closing curly.
Accessing Structure Members
To access any member of a structure, we use the member access operator (.). The member
access operator is coded as a period between the structure variable name and the structure
member that we wish to access. You would use the keyword struct to define variables of
structure type. The following example shows how to use a structure in a program
#include <stdio.h>
#include <string.h>
struct Books {
char title[50];
char author[50];
char subject[100];
int book_id;
};
int main( )
{
struct Books Book1;
/* Declare Book1 of type Book */
struct Books Book2;
/* Declare Book2 of type Book */
/* book 1 specification */
strcpy( Book1.title, "C Programming");
strcpy( Book1.author, "Balaguruswamy");
strcpy( Book1.subject, "C Programming Tutorial");
Book1.book_id = 123456;
/* book 2 specification */
strcpy( Book2.title, "Electrical Machines");
strcpy( Book2.author, "J.B.Gupta");

strcpy( Book2.subject, " Tutorial problems");


Book2.book_id = 654321;
/* print Book1 info */
printf( "Book 1 title : %s\n", Book1.title);
printf( "Book 1 author : %s\n", Book1.author);
printf( "Book 1 subject : %s\n", Book1.subject);
printf( "Book 1 book_id : %d\n", Book1.book_id);
/* print Book2 info */
printf( "Book 2 title : %s\n", Book2.title);
printf( "Book 2 author : %s\n", Book2.author);
printf( "Book 2 subject : %s\n", Book2.subject);
printf( "Book 2 book_id : %d\n", Book2.book_id);
return 0;
}
When the above code is compiled and executed, it produces the following result
Book 1 title : C Programming
Book 1 author : Balaguruswamy
Book 1 subject : C Programming Tutorial
Book 1 book_id : 123456
Book 2 title : Electrical Machines
Book 2 author : J.B.Gupta
Book 2 subject : Electrical Machines
Book 2 book_id : 654321
Structure Initialization
When declare a structure, memory is not allocated for un-initialized variable.
Way 1 : Declare and Initialize
struct student
{
char name[20];
int roll;
float marks;
}std1 = { "Pritesh",67,78.3 };
In the above code , structure is declared and as soon as after declaration structure variable is
initialized
std1 = { "Pritesh",67,78.3 }
This is the code for initializing structure variable in C programming
Way 2 : Declaring and Initializing Multiple Variables

struct student
{
char name[20];
int roll;
float marks;
}
std1 = {"Pritesh",67,78.3};
std2 = {"Don",62,71.3};
In this example, two structure variables are declared in above code. After declaration of variable
we have initialized two variable.
std1 = {"Pritesh",67,78.3};
std2 = {"Don",62,71.3};
Way 3 : Initializing Single member
struct student
{
int mark1;
int mark2;
int mark3;
} sub1={67};
Though there are three members of structure,only one is initialized , Then remaining two
members are initialized with Zero. If there are variables of other data type then their initial
values will be
Data Type

Default value if not initialized

integer

float

0.00

char

NULL

Way 4 : Initializing inside main


struct student
{
int mark1;
int mark2;
int mark3;
};
void main()
{
struct student s1 = {89,54,65};

- - - - -- - - - -- - - - -};
When we declare a structure then memory wont be allocated for the structure. i.e only writing
below declaration statement will never allocate memory
struct student
{
int mark1;
int mark2;
int mark3;
};
We need to initialize structure variable to allocate some memory to the structure.
struct student s1 = {89,54,65};
Rules for Initialization structure
There are few rules to keep in mind while initializing structure variables at compile-time.
1. We cannot initialize individual members inside the structure template.
2. The order of values enclosed in braces must match the order of members in the structure
definition.
3. It is permitted to have a partial initialization. We can initialize only the first few members
and leave the remaining blank. The uninitialized members should be only at the end of
the list.
4. The uninitialized members will be assigned default values, i.e Zero for integer and
floating point numbers and \0 for characters and strings
#include<stdio.h>
#include<conio.h>
struct book_bank
{
char title[20];
char author[15];
int pages;
float price;
};
/* Structure Definition */
void main()
{
struct book_bank book1; /* structure Declaration */
printf(" Input title, author, pages and price of the book \n");
gets(book1.title);
gets(book1.author);

scanf(" %d %f",&book1.pages,&book1.price);
puts(book1.title);
puts(book1.author); /* Accessing strcuture variable*/
printf(" %d \n%f",book1.pages,book1.price);
getch();
}
Output
C programming
John
150
100.99
Unions
A union is a special data type available in C that allows to store different data types in
the same memory location.Union can define with many members, but only one member can
contain a value at any given time. Unions provide an efficient way of using the same memory
location for multiple-purpose.
Defining a Union
To define a union, you must use the union statement in the same way as you did while
defining a structure. The union statement defines a new data type with more than one member for
your program. The format of the union statement is as follows
union [union tag]
{
member definition;
member definition;
...
member definition;
} [one or more union variables];
The union tag is optional and each member definition is a normal variable definition,
such as int i; or float f; or any other valid variable definition. At the end of the union's definition,
before the final semicolon, we can specify one or more union variables but it is optional.
E.g., Define a union type named Data having three members i, f, and str
union Data
{
int i;
float f;
char str[20];
} data;
Now, a variable of Data type can store an integer, a floating-point number, or a string of
characters. It means a single variable, i.e., same memory location, can be used to store multiple

types of data. We can use any built-in or user defined data types inside a union based on our
requirement.
The memory occupied by a union will be large enough to hold the largest member of the
union. For example, in the above example, Data type will occupy 20 bytes of memory space
because this is the maximum space which can be occupied by a character string. The following
example displays the total memory size occupied by the above union
#include <stdio.h>
#include <string.h>
union Data
{
int i;
float f;
char str[20];
};
int main( )
{
union Data data;
printf( "Memory size occupied by data : %d\n", sizeof(data));
return 0;
}
When the above code is compiled and executed, it produces the following result
Memory size occupied by data : 20
Accessing Union Members
To access any member of a union, we use the member access operator (.). The member
access operator is coded as a period between the union variable name and the union member that
we wish to access. You would use the keyword union to define variables of union type. The
following example shows how to use unions in a program
E.g.
#include <stdio.h>
#include <string.h>
union Data
{
int i;
float f;
char str[20];
};
int main( )
{

union Data data;


data.i = 10;
data.f = 220.5;
strcpy( data.str, "C Programming");
printf( "data.i : %d\n", data.i);
printf( "data.f : %f\n", data.f);
printf( "data.str : %s\n", data.str);
return 0;
}
When the above code is compiled and executed, it produces the following result
data.i : 1917853763
data.f : 4122360580327794860452759994368.000000
data.str : C Programming
Here, we can see that the values of i and f members of union got corrupted because the final
value assigned to the variable has occupied the memory location and this is the reason that the
value of str member is getting printed very well.
Now let's look into the same example once again where we will use one variable at a time which
is the main purpose of having unions
#include <stdio.h>
#include <string.h>
union Data
{
int i;
float f;
char str[20];
};
int main( )
{
union Data data;
data.i = 10;
printf( "data.i : %d\n", data.i);
data.f = 220.5;
printf( "data.f : %f\n", data.f);
strcpy( data.str, "C Programming");
printf( "data.str : %s\n", data.str);
return 0;
}
When the above code is compiled and executed, it produces the following result

data.i : 10
data.f : 220.500000
data.str : C Programming
Here, all the members are getting printed very well because one member is being used at a time.