Riphah International University

Faculty of Computing
Object Oriented Programming
Lab 01 Structures

Objectives:

1. Learn about using Functions in C++.

2. To learn how to declare and use C++ struct data type.

Functions in c++:
A function is a group of statements that together perform a task. Every C++ program has at least
one function, which is main(), and all the most trivial programs can define additional functions.
You can divide up your code into separate functions. How you divide up your code among
different functions is up to you, but logically the division usually is such that each function
performs a specific task.
A function declaration tells the compiler about a function's name, return type, and parameters.
A function definition provides the actual body of the function.
The C++ standard library provides numerous built-in functions that your program can call. For
example, function strcat() to concatenate two strings, function memcpy() to copy one memory
location to another location and many more functions.

Defining a function:
The general form of a C++ function definition is as follows –
return_type function_name(
parameter list ) { body of
the function
}

A C++ function definition consists of a function header and a function body. Here are all the
parts of a function −

Return Type − A function may return a value. The return_type is the data type of the value the
function returns. Some functions perform the desired operations without returning a value. In
this case, the return_type is the keyword void.

Function Name − This is the actual name of the function. The function name and the parameter
list together constitute the function signature.
 Parameters − A parameter is like a placeholder. When a function is invoked, you pass a value
to the parameter. This value is referred to as actual parameter or argument. The parameter list
refers to the type, order, and number of the parameters of a function. Parameters are optional;
that is, a function may contain no parameters.

Function Body − The function body contains a collection of statements that define what the
function does.
Example:
Following is the source code for a function called max(). This function takestwo parameters num1
and num2 and return the biggest of both −
// function returning the max between two numbers

int max(int num1, int num2) {

/ local variable
declaration int
result;

if (num1 >
num2)
result =
num1;
else
result = num2;
return result;
}
Defining a function:
A function declaration tells the compiler about a function name and how to call the function.
The actual body of the function can be defined separately.
A function declaration has the following parts −
return_type function_name( parameter list );

For the above defined function max(), following is the function declaration −
int max(int num1, int num2);

Parameter names are not important in function declaration only their type is required, so
following is also valid declaration −
int max(int, int);

Function declaration is required when you define a function in one source file and you call that
function in another file. In such case, you should declare the function at the top of the file calling
the function.

Calling a function:
 While creating a C++ function, you give a definition of what the function has to do. To use a
function, you will have to call or invoke that function.
When a program calls a function, program control is transferred to the called function. A called
function performs defined task and when it’s return statement is executed or when its function-
ending closing brace is reached, it returns program control back to the main program.
To call a function, you simply need to pass the required parameters along with function name,
and if function returns a value, then you can store returned value. For example −

Example:

I kept max() function along with main() function and compiled the source code. While running
final executable, it would produce the following result.
Max value is : 200
Passing an array to a function:
// C++ Program to display marks of 5 students

#include <iostream>
using namespace std;
void display(int m[5]) {
cout << "Displaying marks: " << endl;

// display array elements

for (int i = 0; i < 5; ++i) {
cout << "Student " << i + 1 << ": " << m[i] << endl;
}
}

int main() {

// declare and initialize an array

int marks[5] = {88, 76, 90, 61, 69};

// call display function

// pass array as argument
display(marks);

return 0;
}

 Structure

A structure is a collection of elements of various types. Each of the elements in a structure

is called a data member. Each member is accessed through the use of the member selector
operator.

In C++, a structure is commonly declared according to the following syntax:

struct TypeName
{
MemberList
};

where MemberList is defined as:

DataType MemberName;
DataType MemberName;
 …

 Defining a Structure

As a programmer, you need to define such a structure. The general syntax is:

struct type_name
{
 member_list // these are standard C++
// variable declarations
} ; // note the closing semi-colon

The member_list is where you describe the types of data that are to be associated with the
object that you are defining. For example, the member list for Student is:

string name;
int id;
int mark[3];

Putting this inside the struct definition, we see:

struct Student
{
string name;
int id;
int mark[3];
};

This code just defines the format of the structure. In order to start using this particular
structure you need to declare an instance of it. This is similar to defining a variable of a
predefined type such as int.

 Declaring a Structure Instance

To create an instance of a structure - you need to declare it, just as you would declare an instance
of a primitive data type. Following the example referred to in the previous section, the statement

Student stu;

declares an instance called stu of the structure called Student. Note that the general syntax would
be:

datatype variable_name;

Think back to how you declare an instance of an integer . i.e. int i; // datatype variable_name;

Once you have defined a structure and declared an instance of that structure, you are ready to
start accessing the data elements associated with the instance. These are also referred to as the
members of that instance.
 Using an Instance of a Structure

Again referring back to our little example, suppose you wanted to reference the id value in the
stu instance. How does the C++ compiler know that the variable id is associated with the
instance of a structure? The answer is that you, the programmer, must provide that
information using dot notation. Notice the dot in the general syntax:
structure_instance.member_name

In our example, to refer to id you would need to specify: stu.id

Now, let's have a look at the whole program example and see how the parts and pieces all fit
together.

#include <iostream>
using namespace std;

struct Student
{
string name;
int id;
int mark[3];
};

int main ()
{
Student stu;
int i;

cout << "Your name, please: ";

getline(cin, stu.name); // command to input a string
cout << "Your id is: ";
cin >> stu.id;
cout << "Enter your marks for three tests." << endl;
for (i=0; i < 3; i++)
{
cout << "Test " << i+1 << ": ";
cin >> stu.mark[i];
}

cout << endl;

cout << "Hello, " << stu.name << endl;
cout << "Your Student ID is " << stu.id << endl;
cout << "Your marks are: " << endl;
for (i=0; i < 3; i++)
{
cout << "Test " << i+1 << ": " << stu.mark[i] << " " << endl;
}
}
Exercise 1:

Write a program that uses a structure named LabData to store the following information
about a lab.
 lab title
 lab attendant name
 lab capacity (systems/computers)

The program should create two LabData variables; store values in their members, and
display the information about Lab.

Exercise 2:

Write a program that uses a structure to store the following weather data for a particular
month.
 Total Rainfall
 High Temperature
 Low Temperature
 Average Temperature

Take data for 6 months then calculate and display the total rainfall and average rainfall for 6
months.