When members of a structure are defined as structure type, these are called nested structures. For example:

struct info
{
char s_name[15];
char f_name[15] ;

char city[15] ;
int age;
};
struct p_data
{
info s1;
info s2;
float x;

};
p_data rec;

In the above example, info structure is defined with four members. The structure p_data is defined after the info and it contains three members; two are of structure type and one of float type. The members s1 and s2 within the structure are the nested structures. The structure variable rec is of nested structure type. It is like a structure of array. The structures can he nested to any degree.

Initialization of Nested Structures:

The structure variable that contains members of structure type is initialized as the structure of array is initialized. For example, the above structure variable “rec” may he initialized as:
p_data rec = {{“John”, “William”, London”, 20) {“Joseph”, “Anthony”, “Canada”, 30}, 6.9};

Accessing Members of Nested Structures:

The members of nested structures arc accessed in the same way as the members of simple structures arc accessed. However, to access members of nested structures, more than one dot operators are used.

For example:

rec.s1.age = 22;

In the above statement rec is the name of the structure variable, s1 is member of structure p_data and age is the member of structure info.

A structure variable may also be declared as an array. This is done to manage a large number of records. Each variable of the array represents a complete record.
For example, in the following example the structure variable arts are of array type. It contains 10 elements. Each element can store one record.

struct result
{
char s_name [15];
int sub [4] ;
int total;

};
result arts [10];

There are three members of the above structure. Each member is accessed by one element of the arts array. The indexed variables are used to access these records. The index of first element or record is arts [0]. Similarly, the last record is arts [9].

Initialization of Array of Structure:

Like an array, the data into array of structure variables can also be assigned at the time of its declaration.
For example, in the following example the structure variable “rec” has three elements. The data of fields of each record is enclosed in braces and is separated by commas.

struct marks
{
char code [10];
char name[15];
float marks;
}
marks rec [3] = {{“man-1”, “James ”, 45. 9},
{“acc-l”, “John”, 45.9},
{“fac-l”, “William”, 55.8}};

The members of structure may be of different types. These can also be simple variables or array variables.

For example, in the following structure, the member “sub” is an array of int type. It has four elements. The member “name” is of string type and a string is also an array.

struct rec
{

char name [15];
int sub [4]

};

Method to access the elements of an array that is a member of a structure is the same as for other members. The dot operator is used. To access a specific element of an array of a member, its index value or subscript is used. The variable of a structure type that has an array member is initialized in the usual manner. The members of the array are initialized in the same sequence in which they are defined in the structure.
For example, in the following example, the member “sub” is initialized in the same way as an array variable is initialized.

struct result
{
char name [15];
int sub [4] ;
int total;
result student = {“John”, {62,69,70,40},0};

The values into a structure variable can be assigned when it is declared. It is called initialization of the structure variable. To initialize a structure variable, data is assigned to the members of the structure. To assign data to the members of the structure, the data items are written in the same order in which these have been defined in the structure. The type of the data must also correspond to the type of the member of the structure.

For example, in the structure “address”, member city is of character type and is the first member. The value that is to be assigned to it must be of character type and is written first. Similarly, the second member is pcode. The value that is to be assigned to it must be of integer type and is written second.

struct address
{
char city [15] ;
int pcode;
}
address tag {“London”, 78500};

Program:

Write a program to define a structure with five members. The first member is student name and the other he marks obtained in subjects. Assign values to the members during their declaration. Add the marks of subjects to calculate total marks and then print these numbers and the total marks of the student.

#include <iostream.h>

#include <conio.h>

main ( )

{

struct rec

{

char name [15];

int s1, s2, s3, s4;

};

rec st01 = {“John”, 91, 92, 89, 98};

int total;

total = st01.s1 + st01.s2 + st01.s3 + st01.s4;

clrscr ( );

cout << “Name of student : ” << st01.name << endl;

cout << “Marks in Subject 1 : ” << st01.s1 << endl;

cout << “Marks in Subject 2 : ” << st01.s2 << endl;

cout << “Marks in Subject 3 : ” << st01.s3 << endl;

cout << “Marks in Subject 4 : ” << st01.s4 << endl;

cout << “Total Marks :” << total;

}

A structure is a collection of data items or elements. It is defined to declare its variables. These are called structure variables. A variable of structure type represents the members of its structure.

When a structure type variable is declared, a space is reserved in the computer memory to hold all members of the structure. The memory occupied by a structure variable is equal to the sum of the memory occupied by each member of the structure.
A structure can be defined prior to or inside the main ( ) function. If it is defined inside the main ( ) function then the structure variables can be declared only inside the main function. If’ it is defined prior to the main ( ) function, its variables can be defined anywhere in the program. To declare a structure variable, the structure is first defined, e.g.

struct address

{
char city [15];
int pcode;

}
address taq, aye;

In the above example, city and pcode are the members of structure address. The variable taq and aye are declared as structure variables. The structure address has two members: city and pcode. The variable city occupies 15 bytes and pcode occupies 2 bytes. Thus each variable of this structure will occupy 17 bytes space in memory, i.e. 15 bytes for city and 2 bytes for pcodc.

Accessing Members of a Structure:

The dot operator (.) is used to access the members of a structure. To access a member of a specific structure, the structure variable name, the dot operator and then the member of the structure is written.
The syntax to access a member of a structure is:

struct_variable.struct_element

struct_variable It specifies the name of the structure variable. A period or full-stop specifies the dot operator.
struct_element It specifies the actual element of the structure whose value is to he accessed.

Program: Write a program to input data into and then print data from the members of a structure.

# include <iostream.h>
# include <conio.h>
struct address
{
char city [15];
int pcode;
main ( )
{
address taq;
clrscr ( );
cout << “Enter City ? ”;
cin >> taq.city;
cout << “Enter Postal Code ? ”;
cin >> taq.pcode;
cout << “Output from structure” << endl;
cout << “City:” << taq.city << endl;
cout << “Postal Code:” << taq.pcode << endl;
}

In the above program, a structure address is defined. A variable taq of this structure is declared. The data is entered into the members of the structure address with reference to structure variable taq. The dot operator is used between the structure variable taq and members of the structure.

A structure is a collection of related elements or data items. The elements of the structure are called members of the structure. A structure is unlike an array. All elements in an array are of the same type. But in structures, the elements can be of different types.
The syntax of a structure is very similar to that of a class in C++.  The structures are commonly used in file processing. A file is a collection of related records and a record is a collection of related fields of same or different data type. The structures are also a collection of same or different data types. These are, therefore, also known as records.

Defining a Structure:

Specifying the names, types and number of data items within a structure is called defining of the structure. The keyword “struct” is used to define a structure.
The syntax for defining a structure is:
struct st_name
{
type 1;
type m;
type n;

Where
st name represents the structure name. It is also ca1led structure tag. It is used to declare variables 6f structure type.

type represents the data type of a variable.

l, m, n represents members of the structure. These may have different or same data type. The members are enclosed in braces. A semi-colon after the closing brackets ( }; ) indicates the end of the structure. Each member of a structure must have unique name but different structures may have same names.

A structure is first defined and then variables of structure type are declared. A variable of a structure type is declared to access data in the members of the structure.

Example: Declare a structure with address as tag and having two members name of character type and age of integer type.
struct address
{
char name [15];
int age ;

The structure member name is of character type with 15 characters length (including the null character) and age is of integer type.

The functions that are used to perform mathematical calculations are defined in “math.h” header file. The commonly used math library functions are discussed below.

The “pow” Function:

It is used to calculate the exponential power of a given integer number.
Its syntax is: pow (x ,y);

Where
x : is an integer number whose power is to be calculated.
y : is an integer number that represents the exponent of the number.

Example: If the value of 2³ is to be calculated, the function is written as: pow (2, 3)

The “sqrt” Function:

It is used to calculate the square root of a given positive number. Its syntax is:
sqrt (x);

Where
x : is the positive number of type double (or variable). It also returns a value of type double.
Example: If x = 9.0 then sqrt (x) returns 3.0

The “floor” Function:

It is used to round a given float value to the integer value. The given float value is converted to the largest integer that is not greater than the given float value.
Its syntax is: floor(x);

Where
x: is a float or double value / variable.
Example: If x = 9.6 then floor(x) returns 9.0. If x= -9.6 then floor(x) returns -10.0.

The “ceil” Function:

It is similar to the “floor” function but it returns the rounded integer value greater than the given float or double number. Its syntax is: ceil (x);

Where
x : is the given float or double type given number or value.
Example: If x = 19.2 then ceil(x) returns 20.0. If x= -19.2 then ceil(x) returns -19.0.

The “fmod” Function:

It is used to calculate the remainder by dividing one floating number by another floating number. Its syntax is: fmod (x ,y);
x : represent the nominator. It is a floating number or variable.
y : represent the denominator. It is a floating number or variable.
Example: If x = 9.50 and y =  4.00 then fmod(x, y) returns 1.5. When y = 0, fmod returns 0.

The “cos” Function:

It is used to calculate the trigonometric cosine of a given angle. The angle is given in radians as a floating number. Its syntax is: cos (x);

Where:
x : represents an angle in radians.
Example: If x = 0.0 then cos (x) returns 1.0.

The “sin” Function:

It is used to calculate the trigonometric sine of a given floating number. The angle is given in radians as a floating number. Its syntax is: sin (x)

Where:
x : represents an angle or value in radians.
Example: if x = 0.0 then sin (x) returns 0.

The “tan” Functions:

It is used to calculate the trigonometric tangent of given floating number. The angle is given in radians as a floating number. Its syntax is: tan (x);

Where
x : represents an angle or value in radians
Example: If x = 0.0 then tan (x) returns 0.

The “log” Function:

It is used to calculate the natural logarithm (base e) or a given floating number. Its syntax is: log (x);

Where
x : represents a given floating number.

The “log10” Function:

It is used to calculate the logarithm (base 10) of a given floating number. Its syntax is: log10(x);

Where
x : represents a given floating number.

The “string.h” header file contains the functions that are used to process strings. The commonly used functions of this header file are given below.

The “strlen” Function:

The “strlen” stands for string length. This function is used to find the length of a string. It counts the total number of characters including spaces. Null character is excluded.
Its syntax is:
int strlen (string);

Where string represents the string whose number of characters are to be counted. It may he a constant string or a string type variable. It returns integer type value.

The “strcmp” Function:

The “strcmp” stands for string compare. This function is used to compare two strings. It compares first string with the second string character by character.
Its syntax is:

int strcmp(stringl, string2);

Where
string 1: represents the first string. It may be a string constant or a string type variable.
string 2: represents the second string. It may be a string constant or string type variable.

The “strnemp” Function:

This function is similar to the “strnemp” function but it compares the specified number of characters of the two strings.
Its syntax is:
int strnemp(string 1, string 2, n);

Where

String 1 represents the first string. It may be a string constant or a string type variable.
String 2 represents the second string. It may be a string constant or a string type variable.
n represents a specified number of characters that are to be compared. It may he an integer constant or integer type variable.

The “strcpy” Function:

The “strcpy” stands for string copy. It is used to copy the contents of one string to another string variable including the null character (‘\0’).
Its syntax is:

Strcpy (string l, string 2);

Where
String 1 represents the first string, it must be a string type variable because the contents of string 2 are to be copied into it.
String 2 represents the second string. It may be a string constant or string type variable.
For example, to Copy the string “I love my School” into the string variable “sch”, the statement is written as:
strcpy (sch, “I love my School”);

The “strncpy” Function:

It is similar to “strcpy” function but it is used to copy a specified number of characters from one string to another string variable.
Its syntax is:

strncpy (string 1, string 2, n);

Where
String 1 represents the first string. It must be a string type variable because the first “n” characters of string2 are to be copied into it.
String 2 represents the second string. It may be a string constant or a string type variable. The first “n” characters of this string are copied into the string 1, represents the number of characters of string2 that are to be copied into string 1. It may be an integer constant or an integer type variable.

The “strcat” Function:

The “strcat” stands for string concatenate. It is used to append or combine the contents of one string to another string variable including the null character. Its syntax is:

strcat (string 1 , string 2);

Where
string 1 represents the first string. It must be a string type variable because the contents of string2 are to be added at the end of this string.
string 2 represents the second string. It may be a string constant or a string type variable. The contents of this string are added at the end of the string 1.

The “strncat” Function:

It is similar to “strcat” function hut it is used to append a specified number of characters of one string to another string variable. Its syntax is:

strncat (string l, string2, n);

Where

String 1 represents the first string. It must be a string type variable because the specified number of characters of string2 is appended at the end of this string.
String 2 represents the second string. It may be a string constant or a string type variable. The specified characters of this string are appended at the end of siring 1 represents the number of characters of string 2 that have to be appended at the end of string 1. It may he an integer value or an integer type variable.

The “stdio” stands for standard input/output. This header file contains a large number of standard Input and Output functions that are used to get input from tile input devices and also to print results on output devices.
The commonly used functions of this header file and their description is given below.

The “getchar” Function:

This function is similar to “getch” & “getche” functions of “conio.h” header file, It is also used to get a single character from a standard input device, i.e. from tile keyboard during program execution. The main features of this function are:
• When a character is entered, it is displayed on the screen.
• Enter key must be pressed to complete the input.
Its syntax is:
[var = ] getchar ( );

The use of [var = ] is optional. It is used to store the value of the character entered from the keyboard.

The “putchar” Function:

The “putchar” stands for put character.
It is used to put or print a single character on the standard output device. i.e. the computer screen.

The “gets” Function:

This function is used to get (input) data into a string variable from the keyboard. Any type of characters including space & special characters can he entered using this function. Enter key is pressed after entering the string. When Enter key is pressed a null character is appended at the end of the string.
Its syntax is:

gets (strvar);

where
strvar represents the string type variable into which data is to be entered.

The data in a string type variable can also be entered by using “cin” object but this object is not the most suitable method of inputting data into string variables. When a space key is pressed during input process, the “cin” object immediately appends the null character (‘\O’) at that, place in the string. The characters entered after the spaces are not stored in the string variable.

The “put” Function:

It is used to print a string on the computer screen. The new line is inserted after printing the string.
Its syntax is:

puts (string);

The “string” may be a ring constant or string type variable.
• In case of a string constant, the string is enclosed in double quotes.
• In case of a string variable, it is written without using quotes.

The commonly used built-in functions are discussed below:

The “conio.h” Function:

The “conio.h” stands for console input/output. This header file contains basic input & output functions that are used to get data from the keyboard and to send results from the memory to the output screen. A brief description of commonly used functions of this header file is given below.

The “clrscr” Function:

The “clrscr” stands for clear screen. This function is used to clear the screen of the computer. When this function is executed, the screen is cleared and the cursor shifts to upper left corner, i.e. to row 1 and column 1 of the screen.
Its syntax is: clrscr( );

The “gotoxy” Function:

The “gotoxy” function shifts cursor on the screen to a specified location. This function is used when an output is to he printed on a specified location on the screen. Its syntax is: gotoxy(x, y);
Where
x: the x co-ordinate (or column) on the screen. Its value may he from 0 to 79.
y: the y co-ordinate (or row) on the screen. Its value may he from 0 to 24.

The “clreol” Function:

The “clreol” stands for clear end of line. This function is used to clear a single line from the current cursor position up to the end of line. The other text printed on the screen is not cleared.
Its syntax is: clreol( );

The “getch” Function:

The “getch” stands for get character. This function is used to get a single character from the keyboard during program execution. When a key is pressed:
• The entered character is not displayed on the screen
• Pressing of the Enter key is not required to complete the input. The control shills to the next statement as soon as any key is pressed.
This function is normally used to pause the execution of program. Its syntax is:

[var = ] getch( );

The use of [var = ] is optional. It is used to store the value of the character entered from the keyboard.

The “getche” Function:

This function is similar to “getch’. It is also used to get a single character from keyboard during the program execution. The main difference between “getch” and “getche” is that the entered character is displayed on the screen when “getch” function is used.
Its syntax is: [var = ] getche ( );

The use of [var = ] is optional. It is used to store the value of the cha racier entered from the keyboard.

The “kbhit” Function:

The “kbhit” stands for keyboard hit. This function checks the keyboard hit and returns a non-zero value when a key on the keyboard is hit during program execution. Otherwise it returns zero value.
Its syntax is: [var = ] kbhit( );

The use of [var = ] is optional. It is used to store the value of the character entered from the keyboard.