Learn Object Oriented Programming (OOP) in C++ / সি++ Here
18.10.14
OOP : Excercise-3 : C++ program to calculate simple interest amount use default value for rate
Write a C++ program using class to calculate simple interest amount use default value for rate.
//1. calculate simple interset in cpp
#include<iostream>
using namespace std;
main()
{
float SI=0,p,t,r;
cin>>p>>t>>r;
SI=((p*t*r)/100);
cout<<SI;
}
//2. calculate simple interest using function
#include<iostream>
using namespace std;
float interest(float p,float t,float r);
main()
{
float p,t,r,SI=0;
cin>>p>>t>>r;
interest(p,t,r);
}
float interest(float a,float b,float c)
{
float SI;
SI=((a*b*c)/100);
cout<<SI;
}
//3. calculate simple interest in oop. Use member variable and member function as required
#include<iostream>
using namespace std;
class interest
{
public:
float p,t,r;
void get_value()
{
cin>>p>>t>>r;
}
void cal_value()
{
float SI;
SI=((p*t*r)/100);
cout<<SI;
}
};
main()
{
interest in;
in.get_value();
in.cal_value();
}
OOP : Excercise-2 : calculate square and cube of given number using inline function
C++ program using class to calculate square and cube of given number using inline function .
Sample Syntax:#include<iostream.h>
class power
{
public:
inline int square(int n)
{
-----------------------------
-----------------------------
}
inline int cube(int n)
{
-----------------------------
-----------------------------
}
};
void main()
{
-------------------------------
-------------------------------
}
27.9.14
OOP : Excercise-1 : Arithmetic Operators with operands as input
Write a program performing as calculator which allows all Arithmetic Operators with operands as input
1. Write a C program for performing as calculator which allows all
Arithmetic Operators with operands from terminal. Few Input and Output sample are given below:
Recommended: Study Char/Char Array in C/C++
Sample Input: 1 + 4
Sample
Output: 5
Sample
Input: 8 % 2
Sample
Output: 0
Sample
Input: 6 / 2
Sample
Output: 3
Sample
Input: 5 / 2
Sample
Output: 2.59.3.14
Excercise: Inheritence
Inheritance, Samples of using inheritance
Inheritance is the property by which one object can
inherit the properties of the other object. A general class can be
inherited by the other classes. A class that is inherited is called a
base class. A class which is inheriting another class is called a
derived class. When a class inherits another class, members of the base
class become the members of the derived class. The general form of
inheritance is:-
class derived_name : access_specifier base_name
{
};
The derived_name is the name of the derived class.
The base_name is the name of the base class. The access_specifier can
be private, public or protected. If the access_specifier is public then
all public members of the base class become public members of the
derived class and protected members of the base class become the
protected members of the derived class. If the access_specifier is
private then all public and protected members of the base class will
become private members of the derived class. If the access_specifier is
protected then the public and protected members of the base class
become the protected members of the derived class. Whether
access_specifier is public, private or protected, private members of the
base class will not be accessed by the members of the derived class.
The access_specifier protected provides more
flexibility in terms of inheritance. The private members of the base
class cannot be accessed by the members of the derived class. The
protected members of the base class remain private to their class but
can be accessed and inherited by the derived class. The protected
members of the base class will remain private to the other elements of
the program.
A derived class can inherit one or more base
classes. A constructor of the base is executed first and then the
constructor of derived class is executed. A destructor of derived class
is called before the destructor of base class. The arguments to the
base class constructor can be passed as follows:-
derived_constructor (argument list): base1 (arg_list)
base2(arg_list1)
baseN(arg_list)
The derived_constructor is the name of the derived
class. The argument list is list of the data members of the derived
class. The base1 is name of the base class. The arg_list is the list of
the members of the base class. Here is a program which illustrates the
features of inheritance.
#include<iostream>
using namespace std;
class shape
{
private :
double length;
protected:
double breadth;
public :
double len()
{
return(length);
}
shape(double length1,double breadth1)
{
length=length1;
breadth=breadth1;
}
//shape() { }
};
class shape1
{
public:
double height;
shape1(double height1)
{
height=height1;
}
//shape1() { }
};
class cuboid : public shape, private shape1
{
public:
cuboid(double length1,double breadth1,double height1):shape(length1,breadth1),shape1(height1)
{
cout << " A constructor is called " << endl;
}
double volume()
{
return(height*breadth*len());
}
double bre()
{
return(breadth);
}
double ht()
{
return(height);
}
};
int main()
{
cuboid c1(2.4,3.5,6.7);
cout << "The length of the cuboid is : " << c1.len() << endl;
cout << "The breadth of the cuboid is : " << c1.bre() << endl;
cout << "The height of the cuboid is : " << c1.ht() << endl;
cout << "The volume of the cuboid is : " << c1.volume() << endl;
return(0);
}
The result of the program is:-
The program has two base classes shape and shape1
and one derived class called cuboid which inherits shape as public and
shape1 as private. The public and protected members of shape become
pubic and protected members of derived class cuboid. The private
members of shape remain private to the class shape. The members of
shape1 class become the private members of the derived class cuboid.
The statement
class cuboid : public shape, private shape1
states that class cuboid inherits class shape as public and class shape1 as private. The statement
cuboid(double length1,double breadth1,double height1):shape(length1,breadth1),shape1(height1)
{
cout << " A constructor is called " << endl;
}
declares the constructor of the class cuboid. When
constructor of class cuboid is called first constructor of shape is
executed and then constructor of shape1 is executed and after that the
constructor of cuboid is executed. The statements
double volume()
{
return(height*breadth*len());
}
calculate the volume of the cuboid. The class
cuboid cannot access the private data member length of the shape class.
It access the length by calling the function len() which returns the
private data member length. The data member breadth becomes the
protected member of the class cuboid. The height which is public member
of shape1 class becomes the private member of the class cuboid as it
inherits the shape 1 class as private. The statements
double bre()
{
return(breadth);
}
returns the breadth of the cuboid as data member
breadth cannot be accessed outside the class as it is protected member
of cuboid. The statement
double ht()
{
return(height);
}
returns the height of the cuboid as data member
height cannot be accessed outside the class as height is the private
data member of the class cuboid. The statement
cuboid c1(2.4,3.5,6.7);
creates an object c1 of type cuboid. The
constructor is called to initialize the values of the cuboid. The
constructor of shape is executed and then constructor of shape1 is
executed and then finally constructor of cuboid is executed. The
statement
cout << "The length of the cuboid is : " << c1.len() << endl;
displays the length of the cuboid as c1.len() calls
the len() function of class shape which is also the public member
function of cuboid. The statement
cout << "The breadth of the cuboid is : " << c1.bre() << endl;
displays the breadth of the cuboid. As the data
member breadth cannot be accessed directly as it is protected member of
the class cuboid so the function bre() returns the breadth of the
cuboid. The statement
cout << "The height of the cuboid is : " << c1.ht() << endl;
displays the height of the cuboid. The data member
height cannot be accessed directly as it is private member of class
cuboid so it is accessed through the function ht() which returns
height.
Excercise : Encapsulation
Encapsulation, private public. Sections
The packaging of data values and member functions
within one object is called an encapsulation. For example an object of
class cube contains data member as side of the cube and member function
volume of the cube. It is also called data hiding which helps to
maintain the integrity of the object. It saves the data from misuse and
outside interference. The data cannot be accessed directly but access
controls can be specified in order to obtain the information. The data
or object can be made public or private depending on the needs. The
data which is private is not accessible outside the scope of the
object. When the data is public it can be accessed by the other parts of
the program.
Here is a program which shows how private and
public members are accessed. The program consists of a class rectangle
which has two data members such as length and breadth and the member
functions area() and len(). The private data member length cannot be
accessed directly. It is accessed using a function len() which is
public and which returns the private data member length.
#include<iostream>
using namespace std;
class rectangle
{
private:
double length;
public:
double breadth;
double area()
{
return(length*breadth);
}
double len()
{
return(length);
}
rectangle(double lenght1,double breadth1)
{
length=lenght1;
breadth=breadth1;
}
};
int main()
{
rectangle r1(3.5,4.6);
double a=r1.len();
double b=r1.breadth;
cout << "The lenght is : " << a << endl;
cout << "The breadth is : " << b << endl;
cout << "The area is : " << r1.area() << endl;
return(0);
}
The result of the program is:-
The statement
private:
double length;
declares that data member length of type double
which has access specifier as private. It cannot be accessed directly.
The statements
public:
double breadth;
double area()
{
return(length*breadth);
}
double len()
{
return(length);
}
declares that data member breadth and member
functions len() and area() are public. The member function len() is
used to return the data member length which cannot be accessed
directly. The statement
rectangle r1(3.5,4.6);
declares an object r1 of rectangle. The constructor
initializes the length and breadth of the object as soon as it is
created. The statement
double a=r1.len();
returns the length of the object. The data member
length cannot be accessed directly as it is declared private therefore
member function len() is used to return the value of length. The
statement double a=r1.length in main() function is invalid as data
member length is inaccessible. The statement
double b=r1.breadth;
equates the value of b to the value of breadth of object r1. The statement
cout << "The area is : " << r1.area() << endl;
displays the area of the rectangle.
Exercise : Classes and Objects with Constructor-cum-Destructor
Class and Objects
Constructor and Destructor with Methods and properties
A class is a user defined data type like a
structure or a union. A class consists of data variables and functions.
These variables and functions are called members of the class. The
variables are called data members and functions are called member
functions. The member functions are also called methods. The data
members are called properties of the class. An object is the instance
of the class. An object is like a compound variable of the user defined
type. It links both code and data. Within the object, members of the
class can be public or private to the object. The declaration of a
class is syntactically same as structure. The class is declared using
keyword class. The general form of the declaration of the class is:-
class class_name
{
access_specifier:
data functions
access_specifier:
data functions
} object_list;
The object_list is optional. The object_list is
used to declare objects of the class. The class_name is the name of the
class. The access_specifier can either public, private or protected.
The members of the class by default are private to the class. If the
access_specifier is private then members of the class are not
accessible outside the class. If the access_specifier is public then
members of the class can be accessed from outside the class. The
protected access_specifier is needed at the time of inheritance. The
members can be accessed using an object’s name, a dot operator and name
of the member. Here is a program which shows how classes and objects
are created.
#include<iostream>
using namespace std;
class cube
{
public:
double side;
double volume()
{
return(side*side*side);
}
};
int main()
{
double volume1=0;
cube c1,c2;
cout << "Enter the lenght of the cube" << endl;
cin >> c1.side;
cout << "The volume of the cube is : " << c1.volume() << endl;
c2.side=c1.side +2;
cout << "The volume of the second cube is : " << c2.volume() << endl;
return(0);
}
The result of the program is:-
The program consists of a class cube which has data
member side of type double and member function which calculates the
volume of the cube. The statement
class cube
declares a class cube. The statements
public:
double side;
double volume()
{
return(side*side*side);
}
declare that access_specifier is public for data
member side and member function volume. These members can be accessed
from the other parts of the program. The statement
cube c1,c2;
declares two objects c1 and c2 of type cube. The statement
cin >> c1.side;
access the data member of the cube. The member is
accessed by specifying the name of the object as c1 then dot operator
and then name of the variable side. The length entered by the user is
stored in c1.side. In the statement
cout << "The volume of the cube is : " << c1.volume() << endl;
c1.volume() calls the member function volume which
returns the volume of the cube of side whose length is entered by the
user. The statement
c2.side=c1.side +2;
equates the side of object c2 to side of object c1 increased by 2. The objects c2 and c1 are different. The statement
cout << "The volume of the second cube is : " << c2.volume() << endl;
displays the volume of second object c2.
Constructor and Destructor:
Constructors are used in order to initialize the
objects. A constructor is a special kind of a function which is the
member of the class. The name of the constructor is same as name of the
class. A constructor is automatically called when object is created. A
constructor does not have a return type.
A default constructor is a constructor with no
parameters. If no constructor is defined by the user then compiler
supplies the default constructor. Once the constructor is defined by
the user then compiler does not supply default constructor and then
user is responsible for defining default constructor.
A destructor is the complement of the constructor.
It is used to destroy the objects. The objects are destroyed in order
to deallocate the memory occupied by them. The name of the destructor
is same as the name of the constructor as is preceded by a tilt
operator ‘~’. A destructor for objects is executed in the reverse order
of the constructor functions.
Here is a program which shows how constructors and destructors are used.
#include<iostream>
using namespace std;
class cube
{
public:
double side;
double volume()
{
return(side*side*side);
}
cube(double side1)
{
cout << "A constructor is called" << endl;
side=side1;
}
cube()
{
cout << "A default constructor is called " << endl;
}
~cube()
{
cout << "Destructing " << side << endl;
}
};
int main()
{
cube c1(2.34);
cube c2;
cout << "The side of the cube is: " << c1.side << endl;
cout << "The volume of the first cube is : " << c1.volume() << endl;
cout << "Enter the length of the second cube : " ;
cin >> c2.side;
cout << "The volume of second cube is : " << c2.volume() << endl;
return(0);
}
The result of the program is:-
The statement
cube(double side1)
{
cout << "A constructor is called" << endl;
side=side1;
}
declares the constructor of the class cube. The
name of the constructor is same as the name of the class. There is no
return type in the constructor. It will initialize the value of data
member side. The statement
cube()
{
cout << "A default constructor is called " << endl;
}
declares a default constructor. The statement
~cube()
{
cout << "Destructing " << side << endl;
}
declares a destructor to deallocate the objects. The statement
cube c1(2.34);
creates an object c1 of type cube. A constructor is
automatically called and initializes the data member side with value
2.34. The statement
cube c2;
creates an object of type c2. When object c2 is created a default constructor is called and the message will be printed. The statements
cout << "The side of the cube is: " << c1.side << endl;
cout << "The volume of the first cube is : " << c1.volume() << endl;
displays the side and volume of the cube where side has value 2.34. The statement
cin >> c2.side;
will set the value of
the side of the object c2 as entered by the user. At the end of the
program objects are deallocated in the reverse order in which
constructors are called. First object c2 is deallocated whose side is
2.5 and then object c1 is deallocated whose side is 2.34.
Advantage of the classes:-
It provides protection to the data. The members of
the class are by default private to the class while the members of the
structure are public. OOP features allow programmer to easily handle
complex problems and multi file projects. They help in modeling real
world objects such as bank accounts and their related transactions.
Exercise-1: One steps through integer points of the straight line. The length of a step must be non negative and can be by one bigger than, equal to, or by one smaller than the length of the previous step. What is the minimum number of steps in order to get from x to y ? The length of the f irst and the last step must be 1. View Details
Exercise-2: Some operators checks about the relationship between two values and these operators are called relational operators.
Given two numerical values your job is just to nd out the relationship between them that is
(i) First one is greater than the second
(ii) First one is less than the second or
(iii) First and second one is equal.
View Details
Exercise-1: One steps through integer points of the straight line. The length of a step must be non negative and can be by one bigger than, equal to, or by one smaller than the length of the previous step. What is the minimum number of steps in order to get from x to y ? The length of the f irst and the last step must be 1. View Details
Exercise-2: Some operators checks about the relationship between two values and these operators are called relational operators.
Given two numerical values your job is just to nd out the relationship between them that is
(i) First one is greater than the second
(ii) First one is less than the second or
(iii) First and second one is equal.
View Details
Functions in C++
Functions
Before reading this tutorial you should have knowledge of pointers.
Functions are building blocks of the programs. They
make the programs more modular and easy to read and manage. All C++
programs must contain the function main( ). The execution of the
program starts from the function main( ). A C++ program can contain any
number of functions according to the needs. The general form of the
function is: -
return_type function_name(parameter list)
{
body of the function
}
The function of consists of two parts function header and function body. The function header is:-
return_type function_name(parameter list)
The return_type specifies the type of the data the
function returns. The return_type can be void which means function does
not return any data type. The function_name is the name of the
function. The name of the function should begin with the alphabet or
underscore. The parameter list consists of variables separated with
comma along with their data types. The parameter list could be empty
which means the function do not contain any parameters. The parameter
list should contain both data type and name of the variable. For
example,
int factorial(int n, float j)
is the function header of the function factorial.
The return type is of integer which means function should return data
of type integer. The parameter list contains two variables n and j of
type integer and float respectively. The body of the function performs
the computations.
Function Declaration
A function declaration is made by declaring the
return type of the function, name of the function and the data types of
the parameters of the function. A function declaration is same as
the declaration of the variable. The function declaration is always
terminated by the semicolon. A call to the function cannot be made
unless it is declared. The general form of the declaration is:-
return_type function_name(parameter list);
For example function declaration can be
int factorial(int n1,float j1);
The variables name need not be same as the variables of parameter list of the function. Another method can be
int factorial(int , float);
The variables in the function declaration can be optional but data types are necessary.
Function Arguments
The information is transferred to the function by
the means of arguments when a call to a function is made. Arguments
contain the actual value which is to be passed to the function when it
is called. The sequence of the arguments in the call of the function
should be same as the sequence of the parameters in the parameter list
of the declaration of the function. The data types of the arguments
should correspond with the data types of the parameters. When a
function call is made arguments replace the parameters of the function.
The Return Statement and Return values
A return statement is used to exit from the
function where it is. It returns the execution of the program to the
point where the function call was made. It returns a value to the
calling code. The general form of the return statement is:-
return expression;
The expression evaluates to a value which has type
same as the return type specified in the function declaration. For
example the statement,
return(n);
is the return statement of the factorial function.
The type of variable n should be integer as specified in the
declaration of the factorial function. If a function has return type as
void then return statement does not contain any expression. It is
written as:-
return;
The function with return type as void can ignore
the return statement. The closing braces at the end indicate the exit
of the function. Here is a program which illustrates the working of
functions.
#include<iostream>
using namespace std;
int factorial(int n);
int main ()
{
int n1,fact;
cout <<"Enter the number whose factorial has to be calculated" << endl;
cin >> n1;
fact=factorial(n1);
cout << "The factorial of " << n1 << " is : " << fact << endl;
return(0);
}
int factorial(int n)
{
int i=0,fact=1;
if(n<=1)
{
return(1);
}
else
{
for(i=1;i<=n;i++)
{
fact=fact*i;
}
return(fact);
}
}
The result of the program is:-
The function factorial calculates the factorial of
the number entered by the user. If the number is less than or equal to 1
then function returns 1 else it returns the factorial of the number.
The statement
int factorial(int n);
is a declaration of the function. The return type
is of integer. The parameter list consists of one data type which is
integer. The statement
cout <<"Enter the number whose factorial has to be calculated" << endl;
cin >> n1;
makes the user enter the number whose factorial is
to be calculated. The variable n1 stores the number entered by the
user. The user has entered number 5. The statement
fact=factorial(n1);
makes a call to the function. The variable n1 is
now argument to the function factorial. The argument is mapped to the
parameters in the parameter list of the function. The function header
is
int factorial(int n)
The body of the function contains two return
statements. If the value entered by the user is less than and equal to 1
then value 1 is returned else computed factorial is returned. The type
of the expression returned is integer.
Parameter passing mechanism
There are two parameter passing mechanisms for passing arguments to functions such as pass by value and pass by reference.
Pass by value
In pass be value mechanism copies of the arguments
are created and which are stored in the temporary locations of the
memory. The parameters are mapped to the copies of the arguments
created. The changes made to the parameter do not affect the arguments.
Pass by value mechanism provides security to the calling program. Here
is a program which illustrates the working of pass by value mechanism.
#include<iostream>
using namespace std;
int add(int n);
int main()
{
int number,result;
number=5;
cout << " The initial value of number : " << number << endl;
result=add(number);
cout << " The final value of number : " << number << endl;
cout << " The result is : " << result << endl;
return(0);
}
int add(int number)
{
number=number+100;
return(number);
}
The result of the program is:-
The value of the variable number before calling the
function is 5. The function call is made and function adds 100 to the
parameter number. When the function is returned the result contains the
added value. The final value of the number remains same as 5. This
shows that operation on parameter does not produce effect on arguments.
Pass by reference
Pass by reference is the second way of passing
parameters to the function. The address of the argument is copied into
the parameter. The changes made to the parameter affect the arguments.
The address of the argument is passed to the function and function
modifies the values of the arguments in the calling function. Here is a
program which illustrates the working of pass by reference mechanism.
#include<iostream>
using namespace std;
int add(int &number);
int main ()
{
int number;
int result;
number=5;
cout << "The value of the variable number before calling the function : " << number << endl;
result=add(&number);
cout << "The value of the variable number after the function is returned : " << number << endl;
cout << "The value of result : " << result << endl;
return(0);
}
int add(int &p)
{
*p=*p+100;
return(*p);
}
The result of the program is:-
The address of the variable is passed to the
function. The variable p points to the memory address of the variable
number. The value is incremented by 100. It changes the actual contents
of the variable number. The value of variable number before calling
the function is 100 and after the function is returned the value of
variable number is changed to 105.
After an introduction of functions, let us move on to discuss structures.
Compound Data Types: Pointer in C++
Pointers
Before reading this tutorial, you should have knowledge of arrays.
A pointer is a variable that is used to store a
memory address. The address is the location of the variable in the
memory. Pointers help in allocating memory dynamically. Pointers
improve execution time and saves space. Pointer points to a
particular data type. The general form of declaring pointer is:-
type *variable_name;
type is the base type of the pointer and variable_name is the name of the variable of the pointer. For example,
int *x;
x is the variable name and it is the pointer of type integer.
Pointer Operators
There are two important pointer operators such as ‘*’ and ‘&’. The ‘&’ is a unary operator. The unary operator returns the address of the memory where a variable is located. For example,
int x*;
int c;
x=&c;
variable x is the pointer of the type integer and it points to location of the variable c. When the statement
x=&c;
is executed, ‘&’ operator returns the memory
address of the variable c and as a result x will point to the memory
location of variable c.
The ‘*’ operator is called the indirection operator.
It returns the contents of the memory location pointed to. The
indirection operator is also called deference operator. For example,
int x*;
int c=100;
int p;
x=&c;
p=*x;
variable x is the pointer of integer type. It
points to the address of the location of the variable c. The pointer x
will contain the contents of the memory location of variable c. It will
contain value 100. When statement
p=*x;
is executed, ‘*’ operator returns the content of
the pointer x and variable p will contain value 100 as the pointer x
contain value 100 at its memory location. Here is a program which
illustrates the working of pointers.
#include<iostream>
using namespace std;
int main ()
{
int *x;
int c=200;
int p;
x=&c;
p=*x;
cout << " The address of the memory location of x : " << x << endl;
cout << " The contents of the pointer x : " << *x << endl;
cout << " The contents of the variable p : " << p << endl;
return(0);
}
The result of the program is:-
In the program variable x is the pointer of integer type. The statement
x=&c;
points variable x to the memory location of variable c. The statement
p=*x;
makes the contents of the variable p same as the
contents of the variable c as x is pointing to the memory location of
c. The statement
cout << " The address of the memory location of x : " << x << endl;
prints the memory address of variable x which it is
pointing to. It prints the hexadecimal address 0012FF78. This address
will be different when the program is run on different computers. The
statement
cout << " The contents of the pointer x : " << *x << endl;
prints the contents of memory location of the
variable x which it is pointing to. The contents are same as the
variable c which has value 200. The statement
cout << " The contents of the variable p : " << p << endl;
has the same output 200 as the statement above. The contents of variable p is same as the contents of the pointer x.
Pointer Arithmetic
There are only two arithmetic operations that can
be performed on pointers such as addition and subtraction. The integer
value can be added or subtracted from the pointer. The result of
addition and subtraction is an address. The difference of the two
memory addresses results an integer and not the memory address. When a
pointer is incremented it points to the memory location of the next
element of its base type and when it is decremented it points to the
memory location of the previous element of the same base type. For
example,
int *x;
int *p;
p=x++;
here x and p are pointers of integer type. Pointer x
is incremented by 1. Now variable p points to the memory location next
to the memory location of the pointer x. Suppose memory address of x
is 2000 and as a result p will contain memory address 2004 because
integer type takes four bytes so the memory address is incremented by
4. Incrementing the pointer results in incrementing the memory address
by the number of bytes occupied by the base type. For example,
double *x;
double *p;
p=x++;
variables x and p are pointers of double type.
Pointer x is incremented by 1. Now if the memory address of x was 2000
and after incrementing p will contain memory address 2008 as double
takes 8 bytes. Decrementing the pointer results in decrementing the
memory address by the number of bytes occupied by the base type. You
cannot add two pointers. No multiplication and division can be
performed on pointers. Here is a program which illustrates the working
of pointer arithmetic.
#include<iostream>
using namespace std;
int main ()
{
int *x;
int *p,*q;
int c=100,a;
x=&c;
p=x+2;
q=x-2;
a=p-q;
cout << "The address of x : " << x << endl;
cout << "The address of p after incrementing x by 2 : " << p << endl;
cout << "The address of q after derementing x by 2 : " << q << endl;
cout << " The no of elements between p and q :" << a << endl;
return(0);
}
The result of the program is:-
In the program x, p and q are pointers of integer type. The statement
p=x+2;
makes p to point to the memory address which is next two memory locations apart from the location of x. The statement
q=x-2;
makes q to point to memory address which is previous two memory locations apart from the location of x. The statement
a=p-q;
computes the no of memory locations between p and q will come out to be 4. The statement
cout << "The address of x : " << x << endl;
prints the address of the memory location of x which is 0012FF70. The statement
cout << "The address of p after incrementing x by 2 : " << p << endl;
prints the memory address of p which comes out to
be 0012FF78. Each memory location occupies 4 bytes. Therefore after
incrementing by 2, memory address is incremented by 8. The statement
cout << "The address of q after decrementing x by 2 : " << q << endl;
prints the memory address of q which is 0012FF68. After decrementing, the memory address is decremented by 8. The statement
cout << " The no of elements between p and q :" << a << endl;
prints the no of memory locations between p and q
which comes out to be 4 as p points to next two memory locations of x
and q points to the previous two memory locations of x.
Pointers and Arrays
The pointers and arrays have a very close
relationship. The pointer can be set to the address of the first
element of the array. For example,
int age[];
int *p;
p=&age;
p will point to the address of the first element of the array. For example
(p+4)
will point to the fifth element of the array.
Pointers are helpful where size of the array is unknown. Declaring the
array with a size of large value wastes lot of space. Pointers improve
the execution time. Here is a program which illustrates the working of
arrays and pointers.
#include<iostream>
using namespace std;
int main()
{
int age[5];
int *p;
int sum=0,i;
char yes='y';
p=age;
for(i=0;i<5;i++)
{
cout << "Enter the age of a student" << endl;
cin >> *p;
sum=sum+*p;
p++;
}
p=age;
cout << "The sum of the ages" << sum << endl;\
cout << "The age of the last student is : " << *(p + 4) << endl;
return(0);
}
The result of the program is:-
The array age is of integer type. The pointer p points to the first element of the array.
p=age;
The user is allowed to enter the age of the student. The statement
cin >> *p;
stores the age of the person in contents of the
array. The pointer is incremented by one memory location so that next
time age is stored in new memory location.
p++;
sum of the ages is calculated. The pointer is again
referred to the address of the first element of the array. The age of
the last student cab be accessed using *(p+4) which contains the value of the 5th element of the array.
After an introduction of arrays, let us move on to discuss functions.
Subscribe to:
Posts (Atom)