Data Hiding in C++ with Examples
So those bu ons are nothing but
In this ar cle, I am going to discuss Data Hiding
in C++ with Examples. Please read our previous
ar cle where we discussed How to Create
Objects in Heap Memory using C++ with
Examples. At the end of this ar cle, you will
learn the objec ve of data hiding and why do
you want to hide data.
Data Hiding in C++:
Let us learn about data hiding. This is one of the
important topics in object orienta on and data
hiding is related to encapsula on. A er
encapsula on, we can also achieve data hiding.
What does it mean? Let us see.
class Rectangle
{ func ons should be made public, and data
public:
int length;
int breadth;
int Area ()
{ Imagine it. we have a television box and there
return length * breadth;
} wires that are hanging out, now you can join
int Perimeter ()
{ if you join the wrong wires then the television
return 2 * (length + breadth);
}
};
A class will contain data and func ons. So, data
members and member func ons are together
here inside this class. So by wri ng everything
inside a block i.e. ‘{ }’ we are achieving
encapsula on. But the problem here is we
have made everything as public, data as well as
func ons.
In our previous ar cles already we have given
some examples that if you see a television box,
everything is kept inside the box and even
there will be a warranty seal on the box and
what is visible outside? the bu ons that are
nothing but func ons. Press that bu on then
the func on will be performed. Volume
change, volume will increase or decrease like
that. For all these opera ons bu ons are
available.
func ons. And when you press the bu on,
something happens inside the circuit board to
respond to that par cular func on.
Similarly, if you take an example of a car
everything is covered inside the bonnet and
nothing is visible. Only the func ons are visible
that are at the dashboard and whatever the
opera on that you perform affects the engine
that is inside the bonnet. But you cannot access
bonnet directly. You can access everything
through func ons that are accelera on and
change of gear and all these things.
By observing the products of other
engineering, we can find that only the
should be made private because if the data is
public, we are able to directly create the object
and access data.
are some wires coming out of the box. The
those wires. Some func ons will be performed
may not work properly.
Suppose a television belongs to your company.
I have purchased this television and I’m playing
with those wires. If something wrong happens
then who do I blame? Your company. You did
not make this television properly. I was joining
the wires only but the television is not working
properly, so you will be blamed. You should not
have anything coming out of the television. For
all the func ons you provide bu ons but if
bu ons are not working then you are
responsible. Because what is happening inside,
I don’t know. I am a user. So, you should
provide func ons and when I call those
func ons if it is not working properly then you
are responsible for that.
int main(){
 Rectangle r;
r.length = 10;
r.breadth = 12;
} may not give the correct results and we cannot
In the same way, here we are directly accessing
variables of the class or data members of the
class. If this is your class and if anything goes
wrong then I will blame you. If you hide
everything and say you can access everything
through a func on then you can control
everything.
We have discussed so many things related to
data hiding and we have given various
examples. Now let us see how these things are
related. As in the ‘Rectangle’ class, we made
data members public then if I write,
r.length = -5;
r.breadth = 10;
Can length be nega ve? I don’t know. I’m just a
user. I’m concentra ng on my main func on. I
don’t know what is ‘Rectangle’ class and I don’t
even know that length and breadth can be
nega ve. Now if we write,
cout << r.Area() << endl;
What will be the output? -50. The area cannot
be nega ve. The area is nega ve because we
have set a nega ve length. So, I’m mishandling
things. The things are going wrong because you
have kept length and breadth public and you
are allowing me to access them. So, I can say
that your class is wrong. Your class is not
perfect because it is giving nega ve areas.
So, this is the philosophy behind object-
orienta on. If you think in this way, then you
can design classes properly. So that data
members should not be made public.
Why data members should not be made
public?
If data members are made public then there
are chances that they may be mishandled. If
mishandling is done the func ons of a class
rely on such classes, though it is a mistake of a
programmer. But the class will also be blamed
equally for giving wrong results.
How to Achieve Data Hiding in C++ (Accessors
and Mutators)?
We will make the data members private and
member func ons public,
class Rectangle
{
private:
int length;
int breadth;
public:
int Area ()
{
return length * breadth;
}
int Perimeter ()
{
return 2 * (length + breadth);
}
};
From the point where we have wri en public,
everything below that becomes public. And
same with private. Here we have made data
members private. And by default, everything is
private in a class. We can skip wri ng private
for data members as by default they are
private.
Can we access length or breadth now?
No, we cannot write the value of length or
breadth and even we cannot read the value of
these variables. Then how we can set length
and breadth? We cannot set it directly. If we
write,
Rectangle r;
cout << r.Area() << endl;

Now, what result we will get? See the object ‘r’
is having its length and breadth
Data Hiding in C++ with Examples
We have not ini alized the variables as we are
not allowed to ini alize them. So, both the
variables will have some garbage value. Then if
we print the area, the area func on will
mul ply these two garbage values and give
some garbage value. This is the problem. We
are unable to set that length and breadth then
how to set these values? As we said that
func on should be public so there should be a
‘set’ func on for se ng the length and
breadth. And also, when we want to read it
there should be a ‘get’ func on for ge ng the
value of length and breadth. So, let’s write
those func ons.
For se ng length, we have,
void setLength(int l){
length = l;
} func ons a li le smart by checking the data
This is the func on for se ng the length of the
rectangle. This is taking one parameter which is
the length that we want to set. And inside this,
we assigned the value of ‘l’ to the length
variable. For se ng breadth, we have,
void setBreadth(int b){
breadth = b;
} length = 0;
Here we assigned the value of ‘b’ to the
breadth variable. So, these are the se ers that
will set the given value of length and breadth.
Now let us write ge ers.
int getLength(){
return length;
} }
int getBreadth(){
return breadth;
} data that it is ge ng. If ‘l’ is greater than 0 then
These are the ge er func ons for length and
breadth. Both the func ons are of type ‘int’ as
they are returning an integer value. Now how
to use these func ons? Let us see.
int main(){
Rectangle r;
r.setLength(10);
r.setBreadth(14);
}
Here we have an object of type rectangle in our
main func on. Then we have called the
‘setLength’ and ‘setBreadth’ func ons and
passed some values as parameters. ‘10’ will
store in length and ‘14’ will store in breadth.
How to Achieve Data Hiding in C++ (Accessors
and Mutators)?
We have not directly set the value of length and
breadth but we are calling the func ons of a
class. So, this is a be er way. You can call the
func ons and set the values. So, it is a good
prac ce but s ll, the problem is as it is. See if
we say
r.setBreadth(-5);
It will take -5 and set it into the breadth and s ll
breadth is -5 again. Then what is the benefit of
wri ng the func ons? Now we will make those
they are ge ng and then se ng it. Let us
modify those func ons.
void setLength(int l){
if(l >= 0)
length = l;
else
}
void setBreadth(int b){
if(b >= 0)
breadth = b;
else
breadth = 0;
Now the setLength func on is valida ng the
the only length will be assigned to the length
variable otherwise length will be 0. Same with
breadth func on. We can also write a
statement inside setLength or setBreadth
func on that will inform us that the data is
invalid or nega ve. Now we have a setLength
and setBreadth func ons which validate the
data and assign it. So, if we write,
int main(){
Rectangle r;
r.setLength(10);
r.setBreadth(-5);
cout << r.Area() << endl;
} func ons, and the one which is reading the
Here we are passing -5, so the breadth func on
will set the breadth as zero. Next, we have
called the area func on. Then what will we
get? See length is 10 and breadth is 0 then the
area will be 0. By using the func on, we have
created some condi ons that should be
followed to assign values to data members.
With this, we will not get any wrong results or
nega ve results. But s ll, the main func on is
not knowing or the user is not knowing that
there is a problem with the nega ve value. So,
if you want you can write “length or breadth
cannot be nega ve” inside the setLength and
setBreadth func on. Next, we want to display
the length of a rectangle or breadth of a
rectangle. So, we can say,
r.getLength();
r.getBreadth();
It will give the value of Length and Breadth and
print on the screen. Finally, we have achieved
data hiding. We made the data private and
made the func ons public and because we
were unable to access the data, we have
provided some valida ng func ons or
intelligence which will take the valid data and
assign it to those data members. If it is invalid
then you can print a message that tells the user
that the data is invalid.
How many func ons we have wri en?
The setLengh, setBreadth, getLength and
getbreadth. We have wri en two data
func ons get and set. The ‘get’ will give you the
value of data members and the ‘set’ will
change the value of the data members. So,
whatever the data member, if it is length then
it would getLength, if it is breadth then it will
getBreadth, if it is marks then getMarks, if it is
prize then getPrize. These func ons are called
Accessors and all the set func ons are called
Mutators. Both the func ons se ers and
ge ers are known as property func ons.
Because data numbers are called property. So,
these types of func ons are called property
value is called accessors and the one which is
wri ng the value is called mutator.
Now few more things, for any data member
that is length or breadth, if you are wri ng both
get and set func on then the property is a read
writeable. If you write only accessors or get
func ons and don’t write a set func on, then it
is read-only. You cannot write the property you
cannot change the property so it depends on
you, which property you want to be read
writeable or only readable. Now let us write
the complete program.
Program to Understand Data Hiding in C++:
#include <iostream>
using namespace std;
class Rectangle
{
private:
int length;
int breadth;
public:
void setLength (int l)
{
if (l >= 0)
length = l;
else
{
length = 0;
cout << "Length cannot be nega ve or
zero" << endl;
}
}
void setBreadth (int b)
{
 if (b >= 0) Why do we need Constructors in C++?
breadth = b; Before understanding what are constructors,
else let’s first understand why we need
{ Constructors in C++. For a be er understanding
breadth = 0; please have a look at the below code.
cout << "Breadth cannot be nega ve or
zero" << endl;
} class Rectangle
{
} private:
int getLength () int length;
{ int breadth;
return length; public:
} void setLength (int l)
int getBreadth () {
{ if (l >= 0)
return breadth; length = l;
} else
int Area () length = 0;
{ }
return length * breadth; void setBreadth (int b)
} {
int Perimeter () if (b >= 0)
{ breadth = b;
return 2 * (length + breadth); else
} breadth = 0;
}; }
int main() int getLength ()
{ {
Rectangle r; return length;
r.setLength (10); }
r.setBreadth (10); int getBreadth ()
cout << "Area: " << r.Area () << endl; {
cout << "Perimeter: " << r.Perimeter () << return breadth;
endl; }
} int Area ()
Output: {
return length * breadth;
Constructors in C++ with Examples }
In this ar cle, I am going to discuss int Perimeter ()
Constructors in C++ with Examples. Please read {
our previous ar cle, where we discussed Data return 2 * (length + breadth);
Hiding in C++ with Examples. At the end of this }
ar cle, you will understand what are };
Constructors and their type as well as their role Here we have a class called Rectangle with
and responsibility in C++ Applica ons with length and breadth as data members as well as
Examples. the accessor and mutator methods for these
two data members. Now we will create an
object class Rectangle.
Rectangle r;
The object of the Rectangle class is created
having length and breadth as shown in the
below image.
Why do we need Constructors in C++?
Now, we can access all the func ons of class
Rectangle through object r. Now the problem is
that we have created an object of Rectangle.
We got length and breadth. But what are the
values stored in them? There are no values. Did
we ini alize them? No. So they have garbage
values. Then we want to set the length. So, we
should call the setLength and setBreadth
func ons. We are calling these func ons which
will take the given value and set them to length
and breadth data members. This
Philosophically is totally wrong. Let’s see how.
We have created an object of Rectangle. Later
we set the length and breadth data members.
There is a problem. What is that? Suppose we
have purchased a rectangle from the market.
So, when we purchase it, was it not have any
length and breadth? When we buy something
from the market or when we get something
constructed in some factory and when they
hand over the thing to us then that thing will
have some proper es. Suppose if it is a
rectangle then it must have some length and
breadth. How it can be garbage random length
and breadth? There must be some length and
breadth, not just garbage.
Let’s understand the same concept with one
more example. Suppose we have a car and
color is the property of the car.
You have bought a car and the car will have
some color. What is the color of the car? No
color. How it is possible that you bought a car
from the market and it has no color. When you
placed an order at that me only you said that
I want a white color car or any other color car.
So, the color of this car is white. It is not like
first you will buy a car and bring it home and
then you give white color.
Coming back to our example, first, we are
crea ng a rectangle object, and then only we
are se ng its length and breadth data
members. This Philosophically is wrong. When
you booked the car, at that me only you said
that the car color should be white and then you
should get a white car. That’s it. So, when the
car is delivered, it is having some color, not
garbage.
In the same way, when you are crea ng an
object of Rectangle at that me only, we should
be able to say that I want the length of 10 and
a breadth of 5. You don’t have to set it up later.
So, this is the philosophy behind that one.
We want the length and breadth to be set at
the me of construc on of that object. So,
what we should have inside the class? What is
visible or publicly accessible? Func ons. So, we
should have a func on that should
automa cally be called when an object is
constructed. That func on will take values of
length and breadth as parameters and assign
those values. These func ons are known as
Constructors in C++.
What are Constructors in C++?
C++ allows the object to ini alize itself when it
is created. This automa c ini aliza on of the
object is known as Constructors. The
constructor in C++ is a block of code that
ini alizes the newly created object.
A constructor ini alizes an object immediately
upon crea on. It has the same name as the
class in which it resides and is syntac cally
similar to a method. Once defined, the
constructor is called automa cally immediately
while crea ng the object. Constructors have no
return type, not even void.
So, in simple words, we can define the
constructors in C++ are the special types of
methods of a class that are automa cally
executed whenever we create an instance
(object) of that class. The Constructors are
responsible for two things. One is the object
ini aliza on and the other one is memory
alloca on.
Constructors Examples in C++:
Now, let us try to understand constructors with
some examples. Please have a look at the
below class. The following is a class with the
name Rectangle having two private data
members called length and breadth.
class Rectangle {
private:
int length;
int breadth;
};
Now, let us create an object of the Rectangle
class as follows:
Rectangle r;
An object of Rectangle is created and it will be
shown in the memory as shown in the below
image.
Constructors Examples in C++
As you can see in the above image, this object
(r) is having length and breadth data members.
We can call it as the object is constructed. Who
constructed it? There is a func on that
constructed it i.e. constructor. Did we write any
func on in the class? No. Then who wrote the
func on? The compiler will provide a func on
for this when it converts the class code into
machine code. That is not visible to us. That
constructor will create this object. That means
every class will have some constructor. If we
don’t provide any constructor explicitly, then
the compiler provides a built-in constructor
which is called as default constructor.
Types of Constructors in C++:
A constructor is a func on that will have the
same name as the class name. Can we write
our own constructor? Yes, we can write our
own constructors. Then how we can write? We
can write three different types of constructors.
Non-Parameterized Constructor
Parameterized Constructor
Copy Constructor
Types of Constructors in C++
Note: If you don’t write any of them then a
default constructor is provided by the compiler.
Some mes the non-parameterized constructor
is also called a default constructor and the
default is called also called a built-in
constructor. Now, let us understand all these
constructors through examples.
Default Constructor in C#:
The Constructor without a parameter is called
the default constructor in C++. Again, the
default constructor in C++ is classified into two
types. They are as follows.
System-Defined Default Constructor / Built-in
Constructor
User-Defined Default Constructor
What is System Defined Default Constructor in
C#?
If we are not defined any constructor explicitly
in our class, then by default the compiler will
provide one constructor while genera ng the
machine code. That constructor is called a
default constructor. The default constructor
will assign default values to the data members.
As this constructor is created by the system this
is also called a system-defined default
constructor.
Example to Understand Default Constructor in The constructor which is defined by the user
C++: without any parameter is called a user-defined
In the below example, within the Rectangle default constructor in C++. This constructor
class, we have not defined any constructor does not accept any argument but as part of
explicitly. So, while genera ng the machine the constructor body, you can write your own
code, the compiler will provide the default logic. This is also called a non-parameterized
constructor. constructor as it does not take any parameter.
The following is the syntax.
#include <iostream>
using namespace std;
class Rectangle Rectangle()
{ {
private: length = 10;
int length; breadth = 20;
int breadth; }
public:
Example of User-Defined Default Constructor
void Display() in C++:
{ In the below example, we gave created the
cout << "Length: " << length << " Breadth: constructor without a parameter. This is called
" << breadth; a user-defined default constructor. As part of
} the constructor body, we have ini alized the
}; length and breadth data members with the
int main() values 10 and 20 respec vely. So, when we
{ created an object of the Rectangle class, this
Rectangle r; constructor will call automa cally and set the
r.Display(); length and breadth values 10 and 20.
}
Output: #include <iostream>
Examples to Understand Default Constructor in using namespace std;
C++ class Rectangle
{
private:
Note: The point that you need to remember is int length;
that the compiler will only provide the default int breadth;
constructor if as a programmer you are not public:
defined any constructor explicitly in our class. Rectangle ()
{
When do we need to provide the constructor length = 10;
explicitly in C++? breadth = 20;
If you want to execute some logic at the me }
of object crea on, that logic may be object void Display()
ini aliza on logic or some other useful logic, {
then as a developer, we should define the cout << "Length: " << length << " Breadth:
constructor explicitly in our class. " << breadth;
}
What is a User-Defined Default Constructor in };
C++? int main()
{ and breadth data members respec vely. Now,
Rectangle r; while crea ng the Rectangle object, we need to
r.Display(); provide the values for the l and b parameters
} of the constructor.
Output:
Example of User-Defined Default Constructor #include <iostream>
in C++ using namespace std;
class Rectangle
{
The drawback of the above user-defined private:
default constructor is that every instance (i.e. int length;
for every object) of the class will be ini alized int breadth;
(assigned) with the same values. That means it public:
is not possible to ini alize each instance of the Rectangle (int l, int b){
class with different values. length = l;
breadth = b;
When should we define a Parameterized }
Constructor in a Class? void Display()
If we want to ini alize the object dynamically {
with the user-given values then we need to use cout << "Length: " << length << " Breadth:
the parameterized constructor in C++. The " << breadth;
advantage is that we can ini alize each object }
with different values. };
int main()
What is Parameterized Constructor in C++? {
The user-given constructor with parameters is Rectangle r1(10, 20);
called the parameterized constructor in C++. r1.Display();
With the help of a Parameterized constructor, cout << endl;
we can ini alize each instance of the class with Rectangle r2(30, 40);
different values. That means using r1.Display();
parameterized constructor we can store a }
different set of values in different objects Output:
created in the class. Following is the syntax. Example to understand the Parameterized
Constructor in C++
Rectangle (int l, int b){
length = l;
breadth = b; How many constructors can be defined in a
} class in C++?
The following is the syntax to create the In C++, in a class, we can define one no-
Rectangle object. argument constructor plus “n” number of
Rectangle r1(10, 20); parameterized constructors. But the most
Rectangle r2(30, 40); important point that you need to remember is
that each and every constructor must have a
Example to understand the Parameterized different signature. A different signature
Constructor in C++: means the number, type, and parameter order
In the below example, we have created the should be different.
constructor which takes two integer
parameters and then sets the values of length What is Copy Constructor in C++?
The constructor which takes a parameter of the int length;
class type is called a copy constructor. This int breadth;
constructor is used to copy one object’s data public:
into another object. The main purpose of the Rectangle (int l, int b){
copy constructor is to ini alize a new object length = l;
(instance) with the values of an exis ng object breadth = b;
(instance). The following is the syntax to create }
a Copy Constructor in C++
Rectangle(Rectangle &rect){
Rectangle(Rectangle &rect){ length = rect.length;
length = rect.length; breadth = rect.breadth;
breadth = rect.breadth; }
} void Display()
{
cout << "Length: " << length << " Breadth:
This is a copy constructor. Here, usually, we " << breadth;
take objects by reference and not by value. So }
that when we are calling a constructor, a new };
rectangle object should not be created. So int main()
that’s why we take it as a reference. Then inside {
the constructor, we assign length and breadth Rectangle r1(10, 20);
to the length and breadth of the rect object. r1.Display();
Following is the syntax to call the Copy cout << endl;
Constructor in C++. Rectangle r2(r1);
r2.Display();
Rectangle r2(r1); }
Output:
We have sent the r1 object as a parameter and Example to understand the Copy Constructor in
this will create another rectangle object that is C++
r2. So r will become “rect” here.
What is the Philosophy Behind the
Constructor?
Example to understand the Copy Constructor in Now I will explain to you what is the philosophy
C++ behind the constructor. Let us understand
In the below example, we have created two where we use non-parameterized,
constructors. One is the parameterized parameterized, and copy constructors.
constructor which takes two integer
parameters. The second one is also a
parameterized constructor which takes the Suppose you have placed an order for
class reference as a parameter as it takes the manufacturing a car or o en we directly go to
class reference is a parameter, so it is also the market and buy the items. That item was
called a copy constructor. also manufactured already. They will keep it
ready-made. Just go and buy whatever you
#include <iostream> want.
using namespace std;
class Rectangle Now let us take another example. Suppose you
{ have gone to a shop to buy a marker. Now,
private: what are the op ons you have to buy a marker?
First, you go to a shop and say “give me a
marker”. You did not specify a brand name and
a color for the marker. You did not men on
anything just said I want a marker.
When you said just, I want a marker, whatever
the frequently sold marker is there in the
market or in the shop, he will simply hand over
that marker to you. When you said just pen, so
commonly use the blue color pen of commonly
running brand. So, you will get that pen. So, you
did not give the color or brand so we can say it
is non-parameterized. This is the first method.
I have a rectangle. Ini ally, length and breadth
are 0 later we can change it but ini ally, there
should be something. It cannot be garbage.
Then the second method is when you go to a
shop and say “I want a red color marker of
“xyz” brand”. So, you are men oning some
details here and he will give you that marker
only. So, you have given the parameters. We
can say it is parameterized.
We want a rectangle of length should be 10 and
a breadth should be 5. The third method is
when you went to a shop and you are showing
him a marker and you want a marker like you
to have or copy of that one. So, he will give a
new marker for you that is a copy of the marker
that you already have.
Now we can understand there are three
methods of buying things from a market.
The third is if any person has ‘x’ type of pizza
then I will say that I want that ‘x’ type of pizza
that is a copy of ‘x’.
Points to Remember while working with
Constructors in C++:
A constructor is a member func on of a class
It will have the same name as the class name
It will not have a return type
It should be public
It can be declared private also in some cases
It is called when the object is created
It is used for ini alizing an object
It can be overloaded
If it is not defined then the class will have a
default constructor
Constructors can take default arguments
Types of Constructors:
Non-argument constructor
Parameterized constructor
Copy constructor
All types of Member Func ons:
Constructors – called when the object is
created
Accessors – used for knowing the value of data
members
Mutators – used for changing the value of data
member
Facilitator – actual func ons of class
Enquiry – used for checking if an object
sa sfies some condi on
Destructor – used for releasing resources used
by the object
So, this is the purpose of the constructor and
usage of the constructor. Now let us write the
complete program for constructors

Example to Understand Constructors in C++:

The first one is just going out and saying I want #include <iostream>
this. He will give you. If you go to a restaurant using namespace std;
or food store and say “I want pizza”. If the seller class Rectangle
has only one category of pizza or commonly {
people take the same type of pizza, they will private:
hand it over to you. int length;
Second, if I want a par cular type of pizza like int breadth;
cheese, tomato, Sause, and so on then this is public:
known as parameterized as I am specifying the Rectangle (int l = 0, int b = 0)
pizza type. {
setLength (l);
 setBreadth (b); Output:
} Example to Understand Constructors in C++
Rectangle (Rectangle & rect)
{ How constructors are different from a normal
length = rect.length; member func on?
breadth = rect.breadth; A constructor is different from normal
} func ons in the following ways:
void setLength (int l)
{
if (l >= 0) The Constructor has the same name as the
length = l; class name itself.
else Default Constructors don’t have input
length = 0; arguments however, Copy and Parameterized
} Constructors can have input arguments
void setBreadth (int b) A Constructor should not have a return type,
{ even not void.
if (b >= 0) The constructor will automa cally call when an
breadth = b; object is created.
else It must be placed in the public sec on of the
breadth = 0; class.
} If we do not specify a constructor, the C++
int getLength () compiler generates a default constructor for
{ the object.
return length; Difference Between Func ons and
} Constructors in C++
int getBreadth () Constructors
{ It is a special type of func on used to ini alize
return breadth; objects of their class.
} The purpose of a constructor is to create an
}; object of a class.
int main() Constructor is called automa cally when we
{ are crea ng an object.
Rectangle r; They are used to ini alize objects that don’t
Rectangle r1 (3); exist.
Rectangle r2 (4, 7); The name of the constructor should be the
cout << "r:" << endl; same as the class name of the class.
cout << "Length: " << r.getLength () << " They are not inherited by subclasses.
Breadth: " << r. Func ons:
getBreadth () << endl; Func ons are a set of instruc ons that are
cout << "r1:" << endl; invoked at any point in a program to perform a
cout << "Length: " << r1.getLength () << " specific task.
Breadth: " << r1. The purpose of a func on is to execute C++
getBreadth () << endl; code to perform a specific task.
cout << "r2:" << endl; We need to call explicitly a func on to execute.
cout << "Length: " << r2.getLength () << " They perform opera ons on already created
Breadth: " << r2. objects.
getBreadth () << endl; We can give any valid name to func ons in C++.
} They are inherited by subclasses.