Unit 2

Beginning with C++

• Beginning with C++: Tokens, Data types, Operators,
Expressions, and Control structures, Array

• Functions, Structures and Unions, Class and Objects,

specifying a class, Defining member functions

• Private member functions, Static data and member

functions, Arrays of objects, Friend functions
Basic Program Construction
Let’s look at a very simple C++ program. Extension of programs is CPP
(Test.cpp)

#include <iostream>
using namespace std;
int main()
{
cout << “Every age has a language of its own\n”;
return 0;
}
• The identifier cout (pronounced “C out”) is actually an object. It is
predefined in C++ to correspond to the standard output stream. A
stream is an abstraction that refers to a flow of data.

• The standard output stream normally flows to the screen display.

• The operator << is called the insertion or put to operator. It directs the
contents of the variable on its right to the object on its left.

<< as the left-shift bit-wise operator and wonder how it can also be
used to direct output. In C++, operators can be overloaded. Performing
different activities, depending on the context.
#include <iostream.h> : Pre-processor directive, directs compiler to include
header file iostream.h

The using Directive

• A C++ program can be divided into different namespaces. A namespace is
a part of the program in which certain names are recognized; outside of
the namespace they’re unknown.
• The directive using namespace std; says that all the program statements
that follow are within the std namespace.
• Various program components such as cout are declared within this
namespace. If we didn’t use the using directive, we would need to add the
std name to many program elements.

std::cout << “qwqwwq”;

Variable Int
• Integer variables exist in several sizes, but the most commonly used is
type int. The amount of memory occupied by the integer types is system
dependent. On a 32-bit system such as Windows, an int occupies 4
bytes (which is 32 bits) of memory.
• This allows an int to hold numbers in the range from –2,147,483,648 to
2,147,483,647.
• While type int occupies 4 bytes on current Windows computers, it
occupied only 2 bytes in MS-DOS and earlier versions of Windows.

You must declare a variable before using it. However, you can place
variable declarations anywhere in a program.
It’s not necessary to declare variables before the first executable
statement.
 Declarations and Definitions
• A declaration introduces a variable’s name (such as var1) into a program
and specifies its type (such as int). However, if a declaration also sets aside
memory for the variable, it is also called a definition. The statements
• int var1;
• int var2;

are definitions, as well as declarations, because they set aside memory for
var1 and var2.
Variables are also called Identifiers.
Can use upper and lower-case letters, underscore ( _ ) and digits.

Keyword: is a predefined word with a special meaning.

for eg. int, class, if, and while
Input with cin and Output with cout
>> is the extraction or get from operator

#include <iostream>
using namespace std;
int main()
{
int ftemp; //for temperature in fahrenheit
cout << “Enter temperature in fahrenheit: “;
cin >> ftemp;
int ctemp = (ftemp-32) * 5 / 9;
cout << “Equivalent in Celsius is: “ << ctemp << ‘\n’;
return 0;
}
Output:
Enter temperature in fahrenheit: 212
Equivalent in Celsius is: 100
 Arithmetic Operators

Basic arithmetic operators:

+, -, *, and / for addition, subtraction, multiplication, and division. These
operators work on all the data types, both integer and floating-point.

The Remainder Operator: %

• works only with integer variables (types char, short, int, and long).
• It’s called the remainder operator, and is represented by the percent
symbol (%).
• Also called the modulus operator as it finds the remainder when one
number is divided by another.
#include <iostream>
using namespace std;
int main()
{
cout << 6 % 8 << endl
<< 7 % 8 << endl
<< 8 % 8 << endl
<< 9 % 8 << endl
<< 10 % 8 << endl;
return 0;
}
 Assignment Operators
total = total + item; // adds “item” to “total”
• Arithmetic assignment operator, which combines an arithmetic operator
and an assignment operator and eliminates the repeated operand.
total += item; // adds “item” to “total”

• There are arithmetic assignment operators corresponding to all the

arithmetic operations: +=, -=, *=, /=, and %=

count = count + 1; // adds 1 to “count”

count += 1;
++count;

?
Prefix
Increment
operator

Postfix
Increment
operator
 Library Functions

These functions perform file access, mathematical computations,

and data conversion, among other things.
Eg., sqrt()
X=Sqrt(64);

Remember to #include <cmath>

Error: ‘sqrt’ unidentified identifier

Two Ways to Use #include

1. angle brackets < and > surrounding the filenames

• IOSTREAM and CMATH in the SQRT example indicate that the
compiler should begin searching for these files in the standard
INCLUDE directory. This directory, which is traditionally called
INCLUDE, holds the header files supplied by the compiler
manufacturer for the system.
2. quotation marks, “ and “ surrounding the filenames
• #include “myheader.h” Quotation marks instruct the compiler to begin
its search for the header file in the current directory; this is usually the
directory that contains the source file.

Use quotation marks for header files you write yourself

Relational Operators

A relational operator compares two values. The values can be

any built-in C++ data type, such as char, int, and float.

Operator Meaning
   
>  Greater than (greater than)
<  Less than
== Equal to
!= Not equal to
>= Greater than or equal to
<= Less than or equal to
 Loops

• Loops cause a section of your program to be repeated a certain

number of times. The repetition continues while a condition is
true. When the condition becomes false, the loop ends and
control passes to the statements following the loop.
• There are three kinds of loops in C++: the for loop, the while
loop, and the do loop.
#include <iostream>
using namespace std;
int main()
{
int j; //define a loop variable
for(j=0; j<15; j++)
cout << j * j << “ “;
cout << endl;
return 0;
}
Loops

#include <iostream>
using namespace std;
int main()
{
int j; //define a loop variable
for(j=0; j<15; j++)
cout << j * j << “ “;
cout << endl;
return 0;
}

Output
0 1 4 9 16 25 36 49 64 81 100 121 144 169 196
#include <iomanip>
using namespace std;
int main()
{
int numb; //define loop variable
for(numb=1; numb<=10; numb++) //loop from 1 to 10
{
cout << setw(4) << numb; //display 1st column
int cube = numb*numb*numb; //calculate cube
cout << setw(6) << cube << endl; //display 2nd column
}
return 0;
}
#include <iomanip>
using namespace std;
int main()
{
int numb; //define loop variable
for(numb=1; numb<=10; numb++) //loop from 1 to 10
{
cout << setw(4) << numb; //display 1st column
int cube = numb*numb*numb; //calculate cube
cout << setw(6) << cube << endl; //display 2nd column
}
return 0;
}
1 1
2 8
3 27
4 64
5 125
6 216
7 343
8 512
9 729
10 1000
 Decisions
1. if...else statement, which chooses between two alternatives. This statement
can be used without the else, as a simple if statement.
2. switch, creates branches for multiple alternative sections of code, depending
on the value of a single variable.
3. Conditional operator

#include <iostream> #include <iostream>

using namespace std; using namespace std;
int main() int main()
{ {
int x; int x;
cout << “Enter a number: “; cout << “Enter a number: “;
cin >> x; cin >> x;
if( x > 100 ) while( x > 100 )
cout << “That number is greater cout << “That number is greater
than100”; than100”;
return 0; return 0;
} }
 5-4-2= 1-2=-1
Operator Precedence Left to right, whichever operator comes first
6+3*1 = 6+3
2$3$4 = 2$81
$ pow(x,y) xy pow(2,3)

Brackets supersede all other precedence, means it has highest priority

Tutorial 2
Q1. Describe all data type available in C++ language.
Make a table showing Keyword used || Numerical Range || Bytes
Q2. What is type conversion? How it happens in C++.
Q3. How and when to use type casting?
Q4. How is increment/decrement prefix and postfix operator applied?
Q5. Differentiate between header files and library files.
Q6. A library function, islower(), takes a single character (a letter) as an argument and returns a
nonzero integer if the letter is lowercase, or zero if it is uppercase. This function requires the
header file CTYPE.H. Write a program that allows the user to enter a letter, and then displays
either zero or nonzero, depending on whether a lowercase or uppercase letter was entered.
Q7. Write a temperature-conversion program that gives the user the option of converting
Fahrenheit to Celsius or Celsius to Fahrenheit. Then carry out the conversion. Use floating-point
numbers. Interaction with the program might look like this:
Type 1 to convert Fahrenheit to Celsius, 2 to convert Celsius to Fahrenheit
Q8. Write a program that repeatedly asks for a number and calculates its factorial, until the user
enters 0, at which point it terminates. You can enclose the relevant statements in FACTOR in a
while loop or a do loop to achieve this effect.
Structures
• A structure is a collection of simple variables. The variables in a
structure can be of different types: int, float, and so on.

• The data items in a structure are called the members of the structure.
struct student
{
int rollno;
char name[20];
int phno;
};
student s1,s2;
s1.rollno=200101;
Structures Within Structures
struct Distance
{
int feet;
float inches;
};
struct Room
{
Distance length;
Distance width;
};

Room dining;
dining.length.feet=10;
dining.length.inches=2.5;
dining.width.feet=5;
dining.width.inches=1.5;

//compute area- first convert inches to feet

float l= dining.length.feet + dining.length.inches/12;
float w= dining.width.feet + dining.width.inches/12;
Area= l * w;
Functions

A function groups a number of

program statements into a unit
and gives it a name.

• Structured programming
• Reduce program size
• Function code is stored in only
one place in memory
Passing Arguments to Functions
• An argument is a piece of data (an int value, for example) passed from a program to the
function.
• Arguments allow a function to operate with different values, or even to do different
things, depending on the requirements of the program calling it.
• In the next program, TableArg, includes a function. In this program, arguments are
used to pass the character to be printed and the number of times to print it.

Reference Arguments
• A reference provides an alias—a different name—for a variable.
• When arguments are passed by value, the called function creates a new variable of the
same type as the argument and copies the argument’s value into it.
• The function cannot access the original variable in the calling program, only the copy it
created. Passing arguments by value is useful when the function does not need to
modify the original variable in the calling program.
• Passing arguments by reference uses a different mechanism. Instead of a value being
passed to the function, a reference to the original variable, in the calling program, is
passed.
• In this case, the memory address of the variable is passed.
//Program TableArg
// function definition
void repchar(char ch, int n) //function
#include <iostream> declarator
using namespace std; {
void repchar(char, int); //function declaration for(int j=0; j<n; j++) //function body
int main() cout << ch;
{ cout << endl;
repchar(‘-’, 43); //call to function }
cout << “Data type Range” << endl;
repchar(‘=’, 23); //call to function

cout << “char -128 to 127” << endl

<< “short -32,768 to 32,767” << endl
<< “int System dependent” << endl
<< “long -2,147,483,648 to
2,147,483,647” << endl;

repchar(‘-’, 43); //call to function

return 0;
}
//Program TableArg
// function definition
void repchar(char ch, int n) //function
#include <iostream> declarator
using namespace std; {
void repchar(char, int); //function declaration for(int j=0; j<n; j++) //function body
int main() cout << ch;
{ cout << endl;
repchar(‘-’, 43); //call to function }
cout << “Data type Range” << endl;
repchar(‘=’, 23); //call to function -------------------------------------------
Data type Range
cout << “char -128 to 127” << endl =======================
<< “short -32,768 to 32,767” << endl char -128 to 127
<< “int System dependent” << endl short -32,768 to 32,767
<< “long -2,147,483,648 to int System dependent
2,147,483,647” << endl; long -2,147,483,648 to 2,147,483,647
-------------------------------------------
repchar(‘-’, 43); //call to function
return 0;
}
// demonstrates variable arguments :VarArg.cpp
#include <iostream>
using namespace std;
void repchar(char, int); //function declaration
int main()
{
char chin;
int nin;
cout << “Enter a character: “;
cin >> chin;
cout << “Enter number of times to repeat it: “;
cin >> nin;
repchar(chin, nin);
return 0;
}
// function definition
void repchar(char ch, int n) //function declarator
{
for(int j=0; j<n; j++) //function body
cout << ch;
cout << endl;
}
// demonstrates variable arguments :VarArg.cpp
#include <iostream> Enter a character: +
using namespace std; Enter number of times to repeat it: 20
void repchar(char, int); //function declaration ++++++++++++++++++++
int main()
{ The data types of variables used as
char chin; arguments must match those specified in
int nin; the function declaration and definition.
cout << “Enter a character: “;
cin >> chin; In VarArg.cpp the particular values
cout << “Enter number of times to repeat it: “;
possessed by chin and nin when the
cin >> nin;
function call is executed will be passed to
repchar(chin, nin);
return 0;
the function. The function gives these new
} variables the names and data types of the
// function definition parameters specified in the declarator:
void repchar(char ch, int n) //function declarator ch of type char and n of type int.
{
for(int j=0; j<n; j++) //function body It initializes these parameters to the values
cout << ch; passed.
cout << endl; They are then accessed like other variables
} by statements in the function body.
#include <iostream> // display structure of type Distance in feet & inches
using namespace std; void disp( Distance dd ) //parameter of type Distance
struct Distance {
{ cout << dd.feet << “\’-” << dd.inches << “\””;
int feet; }
float inches;
};
void disp( Distance ); //declaration
int main()
{ Output:
Distance d1, d2; //define two lengths
//get length d1 from user Enter feet: 6
cout << “Enter feet: “; cin >> d1.feet; Enter inches: 4
cout << “Enter inches: “; cin >> d1.inches; Enter feet: 5
//get length d2 from user Enter inches: 4.25
cout << “\nEnter feet: “; cin >> d2.feet; d1 = 6’-4”
cout << “Enter inches: “; cin >> d2.inches; d2 = 5’-4.25”
cout << “\nd1 = “;
disp(d1); //display length 1
cout << “\nd2 = “;
disp(d2); //display length 2
cout << endl;
return 0;
}
#include <iostream> // display structure of type Distance in feet & inches
using namespace std; void disp( Distance dd ) //parameter of type Distance
struct Distance {
{ cout << dd.feet << “\’-” << dd.inches << “\””;
int feet; }
float inches;
};
void disp( Distance ); //declaration
int main()
{
Distance d1, d2; //define two lengths
//get length d1 from user
cout << “Enter feet: “; cin >> d1.feet;
cout << “Enter inches: “; cin >> d1.inches;
//get length d2 from user
cout << “\nEnter feet: “; cin >> d2.feet;
cout << “Enter inches: “; cin >> d2.inches;
cout << “\nd1 = “;
disp(d1); //display length 1
cout << “\nd2 = “;
disp(d2); //display length 2
cout << endl;
return 0;
}
#include <iostream> // display structure of type Distance in feet & inches
using namespace std; void disp( Distance dd ) //parameter of type Distance
struct Distance {
{ dd. Feet=2;
int feet; dd.inches=3.25;
float inches; cout<<"\n in function:";
}; cout << dd.feet << “\’-” << dd.inches << “\””;
void disp( Distance ); //declaration }
int main()
{ Output:
Distance d1, d2; //define two lengths
//get length d1 from user Enter feet: 6
cout << “Enter feet: “; cin >> d1.feet; Enter inches: 4
cout << “Enter inches: “; cin >> d1.inches; Enter feet: 5
//get length d2 from user Enter inches: 4.25
cout << “\nEnter feet: “; cin >> d2.feet; d1= 6’-4”
cout << “Enter inches: “; cin >> d2.inches; In function: 2’-3.25”
cout << “\nd1 = “;
disp(d1); //display length 1 d2 =
cout << “\nd2 = “; In function: 2’-3.25”
disp(d2); //display length 2
cout << endl;
return 0;
}
 Pass by Reference
#include <iostream> //orders two numbers

using namespace std; void order(int& numb1, int& numb2)

int main() {
if(numb1 > numb2) //if 1st > 2nd,
{ {
void order(int&, int&); //prototype int temp = numb1; //swap them
numb1 = numb2;
int n1=99, n2=11; //this pair not ordered
numb2 = temp;
int n3=22, n4=88; //this pair ordered }
order(n1, n2); //order each pair of numbers }

order(n3, n4);
cout << “n1=” << n1 << endl; //print all nos
cout << “n2=” << n2 << endl;
cout << “n3=” << n3 << endl;
cout << “n4=” << n4 << endl;
return 0;
}
 Pass by Reference
#include <iostream> //orders two numbers

using namespace std; void order(int& numb1, int& numb2)

int main() {
if(numb1 > numb2) //if 1st > 2nd,
{ {
void order(int&, int&); //prototype int temp = numb1; //swap them
numb1 = numb2;
int n1=99, n2=11; //this pair not ordered
numb2 = temp;
int n3=22, n4=88; //this pair ordered }
order(n1, n2); //order each pair of numbers }

order(n3, n4);
cout << “n1=” << n1 << endl; //print all nos Output: Output:
cout << “n2=” << n2 << endl; Before Call After Call
n1=99 n1=11
cout << “n3=” << n3 << endl; n2=11 n2=99
cout << “n4=” << n4 << endl; n3=22 n3=22
return 0; n4=88 n4=88
}
Defining Class
Private and Public

Data hiding

• Data is concealed
into a class,
• Doesn’t allow access
by outside functions
• Private Data and
functions are hidden
from other classes or
parts of the program
 Using class
Creating object/ Instantiating object/ Instance variables

Define Class Define Object & call member functions

Class Student main( )
{ {
Private: // define two objects of class Student
int rollno; Student s1,s2;
Public: s1.read_data(10); //message
void read_data(int r) s1.put_data();
{ s2.read_data(20);
rollno=r; s2.put_data();
} }
void put_data()
{ Object s1 Object s2
cout<<“\n Rollno is:” <<rollno; rollno:10 rollno:20
}
}
 C++ Objects as Data Types
#include <iostream> //distanceclass.cpp int main()
using namespace std; {
class Distance //Distance class Distance dist1, dist2;//define lengths
{ dist1.setdist(11, 6.25); //set dist1
private: dist2.getdist(); //get dist2 from user
int feet; //display lengths
float inches; cout << “\ndist1 = “; dist1.showdist();
public: cout << “\ndist2 = “; dist2.showdist();
void setdist(int ft, float in) //set Distance to args cout << endl;
{ return 0;
feet = ft; inches = in; }
}
void getdist() //get length from user
{
cout << “\nEnter feet: “; cin >> feet; Output:
cout << “Enter inches: “; cin >> inches;
} Enter feet: 10
void showdist() //display distance Enter inches: 4.75
{ dist1 = 11’-6.25” ←provided by arguments
cout << feet << “\’-” << inches << ‘\”’; dist2 = 10’-4.75” ←input by the user
}
};
Class can be defined inside a function ?
#include<iostream>
using namespace std;
void fun()
{
class Test // local to fun
{
public: // method is defined inside the local class
void method()
{
cout << "Local Class method() called";
}
};
Test t;
t.method();
}
int main()
{
fun();
return 0;
}
 Access Specifiers or Modifiers
• Used to implement data hiding.
• Access modifiers or Access Specifiers in a class are used to set the
accessibility of the class members.
• It sets some restrictions on the class members not to get directly accessed
by the outside functions.

There are 3 types of access modifiers available in C++:

• Public
• Private
• Protected

• If we do not specify any access modifiers for the members inside the class
then by default the access modifier for the members will be Private.
 Access Specifiers or Modifiers : Public
Public:
• All the class members declared under public will be available to everyone.
• The data members and member functions declared public can be accessed by other classes
too.
• The public members of a class can be accessed from anywhere in the program using the
direct member access operator (.) with the object of that class.

#include<iostream> int main()

using namespace std; {
// class definition Circle obj;
class Circle // accessing public datamember outside class
{ obj.radius = 5.5;
public: cout << "Radius is:" << obj.radius << "\n";
double radius; cout << "Area is:" << obj.compute_area();
double compute_area() return 0;
{ }
return 3.14*radius*radius;
} Radius is:5.5
}; Area is:94.985
 Access Specifiers or Modifiers: Private
Private:
• The class members declared as private can be accessed only by the functions inside the
class.
• They are not allowed to be accessed directly by any object or function outside the class.
• Only the member functions or the friend functions are allowed to access the private data
members of a class.

using namespace std; int main()

class Circle {
{ // creating object of the class
private: Circle obj;
double radius; // private data member // trying to access private data member
// public member function // directly outside the class
public: obj.radius = 1.5;
double compute_area()
cout << "Area is:" << obj.compute_area();
{ // member function can access private
// data member radius return 0;
return 3.14*radius*radius; }
}
};
 Access Specifiers or Modifiers: Private

using namespace std;

class Circle
{
private: int main()
double radius; // private data member {
// public member function // creating object of the class
public:
Circle obj;
double compute_area()
{ // member function can access private
// trying to access private data member
// data member radius // directly outside the class
return 3.14*radius*radius; obj.radius = 1.5; //compile error
} cout << "Area is:" << obj.compute_area();
}; return 0;
}
#include<iostream>
int main()
using namespace std;
{
class Circle
// creating object of the class
{
Circle obj;
// private data member
private:
obj.compute_area(1.5);
double radius;
// public member function
public:
return 0;
void compute_area(double r)
}
{ // member function can access private
// data member radius
radius = r; Output:

double area = 3.14*radius*radius;

cout << "Radius is:" << radius << endl;

cout << "Area is: " << area;
}

};
#include <iostream>
int main()
using namespace std;
{
class Rectangle
Rectangle rt1, rt2;
{
rt1. Set_Data(7, 4);
private:
rt2. Set_Data(4, 5);
int length, breadth;
cout << "Area 1st rect:" << rt1.printArea() << endl;
public:
cout << "Area 2nd rect:" << rt2.printArea() << endl;
void Set_Data( int l, int b )
return 0;
{
}
length = l;
breadth = b;
}
int printArea()
{
return length * breadth;
}
};
#include <iostream>
int main()
using namespace std;
{
class Rectangle
Rectangle rt1, rt2;
{
rt1. Set_Data(7, 4);
private:
rt2. Set_Data(4, 5);
int length, breadth;
cout << "Area 1st rect:" << rt1.printArea() << endl;
public:
cout << "Area 2nd rect:" << rt2.printArea() << endl;
void Set_Data( int l, int b )
return 0;
{
}
length = l;
breadth = b;
}
int printArea() Output:
{ Area of 1st rect:28
return length * breadth; Area of 2nd rect:20
}
};
Array
1-D Array

2-D Array
Linear Search
• Suppose we have 50 students in a class and we have to
input the name and marks of all the 50 students.

• Creating 50 different objects and then inputting the name

and marks of all those 50 students is a good option. ?

• Alternative is create an array of objects.

#include <iostream> int main()
using namespace std; {
class Student Student st[5]; //Array of objects
{ for( int i=0; i<5; i++ )
{
char name[20];
cout << "Student " << i + 1 << endl;
int marks; cout << "Enter name" << endl;
public: st[i].getName();
void getName() cout << "Enter marks" << endl;
{ st[i].getMarks();
cin>> name; }
}
void getMarks() for( int i=0; i<5; i++ )
{ {
cin >> marks; cout << "Student " << i + 1 << endl;
st[i].displayInfo();
}
}
void displayInfo() return 0;
{ }
cout << "Name: " << name << endl;
cout << "Marks: " << marks << endl;
}
};
Defining Member Functions

Can be defined at two places:

• Inside class definition

• Outside class definition using scope resolution operator (::)

The code of the function is same in both the cases, but the
function header is different
Inside Class Definition:
• When a member function is defined inside a class, we do not
require to place a membership label along with the function
name. We use only small functions inside the class definition
and such functions are known as inline functions.

• In case of inline function the compiler inserts the code of the

body of the function at the place where it is invoked (called)
and in doing so the program execution is faster but memory
penalty is there.
Outside Class Definition:
Using Scope Resolution Operator (::) :
• In this case the function’s full name (qualified_name) is written as
shown:
Name_of_the_class :: function_name

• The syntax for a member function definition outside the class

definition is :
return_type name_of_the_class::function_name (argument list)
{
body of function
}
#include <iostream> int main()
using namespace std; {
class Student
{ Student S1;
public: S1.student_name = “Parminder";
string student_name; S1.roll_no=15;
int roll_no;
// call print_name()
// print_name is not defined inside class definition S1.print_name();
void print_name(); cout << endl;

// print_id is defined inside class definition // call print_rollno()

void print_rollno() S1.print_rollno();
{ return 0;
cout << “Student rollno: " << roll_no; }
}
};
// Definition of print_name using scope resolution
operator ::
void Student::print_name()
{
cout << “Student name is: " <<student_name;
}
Friend Function

• A friend function of a class is defined outside that class' scope

but it has the right to access all private and protected
members of the class. Even though the prototypes for friend
functions appear in the class definition, friends are not
member functions.
• A friend can be a function, function template, or member
function, or a class or class template, in which case the entire
class and all of its members are friends.
• To declare a function as a friend of a class, precede the
function prototype in the class definition with keyword friend.
 class Box
{
double width;
public:
double length;
friend void printWidth( Box box );
void setWidth( double wid );
};

To declare all member functions of class Class2 as friends of class Class1, place following
declaration in the definition of class ClassOne −

friend class class2;

#include <iostream> int main()
using namespace std; {
class Box Box box;
{
double width; // set box width without member
public: function
friend void printWidth( Box box ); box.setWidth(10.0);
void setWidth( double wid );
}; // Use friend function to print the width.
printWidth( box );
// Member function definition
void Box::setWidth( double wid ) return 0;
{ }
width = wid;
}

// Note: printWidth() is not a member function of any class.

void printWidth( Box box )
{
// Because printWidth() is a friend of Box, it can directly
//access any member of this class
cout << "Width of box : " << box.width <<endl;
}
Consider a shopping list of items for which we place order with a
dealer every month. The List includes details such as the code
number and price of each item. Perform operations like adding
an item to the list, deleting an item from the list and printing
total value of the order. Write a C++ program to implement this,
user should have a menu to choose operation.