Access specifier

C++ ACCESS SPECIFIERS
 C++ access specifiers are used for determining or setting the boundary for the
availability of class members (data members and member functions) beyond that
class.
For example, the class members are grouped into sections, private protected and
public. These keywords are called access specifiers which define the accessibility
or visibility level of class members.
By default the class members are private. So if the visibility labels are missing then
by default all the class members are private.
In inheritance, it is important to know when a member function in the base class
can be used by the objects of the derived class. This is called accessibility and the
access specifiers are used to determine this.

C++ ACCESS SPECIFIERS
Access specifier can be either private or protected or public. In
general access specifiers are the access restriction imposed during the
derivation of different subclasses from the base class.
 private access specifier
 protected access specifier
 public access specifier

VISIBILITY MODES
Public: When the member is declared as public, it is accessible to all
the functions of the program.
Private: When the member is declared as private, it is accessible
within the class only.
Protected: When the member is declared as protected, it is
accessible within its own class as well as the class immediately
derived from it.

PRIVATE ACCESS SPECIFIER
• If private access specifier is used while creating a class, then the
public and protected data members of the base class become the
private member of the derived class and private member of base
class remains private.
• In this case, the members of the base class can be used only within
the derived class and cannot be accessed through the object of
derived class whereas they can be accessed by creating a function
in the derived class.

SAMPLE PROGRAM DEMONSTRATING PRIVATE
ACCESS SPECIFIER
• Note: Declaring data members with private access specifier is known as data hiding.
#include <iostream>
using namespace std;
class base
{
private:
int x;
protected:
int y;

ACCESS SPECIFIER
public:
int z;
base() //constructor to initialize data
members
{
x = 1;
y = 2;
z = 3;
}
};
class derive: private base
{
//y and z becomes private members of class
derive and x remains private
public:
void showdata()
{
cout << "x is not accessible" << endl;
cout << "value of y is " << y << endl;
cout << "value of z is " << z << endl;
}

ACCESS SPECIFIER
};
int main()
{
derive a; //object of derived class
a.showdata();
return 0;
} //end of program
Output
x is not accessible
value of y is 2
value of z is 3

EXPLANATION
• When a class is derived from the base class with private access specifier the
private members of the base class can’t be accessed. So in above program, the
derived class cannot access the
• So in above program, the derived class cannot access the member x which is
private in the base class, however, derive class has access to the protected and
public members of the base class. So the
• Hence the function showdata in derived class can access the public and
protected member of the base class.

PROTECTED ACCESS SPECIFIER
• If protected access specifier is used while deriving class then the
public and protected data members of the base class becomes the
protected member of the derived class and private member of the
base class are inaccessible.
• In this case, the members of the base class can be used only within
the derived class as protected members except for the private
members.

SAMPLE PROGRAM DEMONSTRATING PROTECTED
ACCESS SPECIFIER
#include <iostream>
class base
{
private:
int x;
protected:
int y;
public:
int z;
members
{
x = 1;
y = 2;
z = 3;
}
};

ACCESS SPECIFIER
class derive: protected base
{
//y and z becomes protected members
of class derive
public:
void showdata()
{
}
};
int main()
{
a.showdata();
return 0; }

ACCESS SPECIFIER
Output
x is not accessible
value of y is 2
value of z is 3

PUBLIC ACCESS SPECIFIER
• If public access specifier is used while deriving class then
the public data members of the base class becomes the
public member of the derived class and protected
members becomes the protected in the derived class but
the private members of the base class are inaccessible.

SAMPLE PROGRAM DEMONSTRATING PUBLIC
ACCESS SPECIFIER
#include <iostream>
class base
{
private:
int x;
protected:
int y;
public:
int z;
members
{
x = 1;
y = 2;
z = 3;
}
};

ACCESS SPECIFIER
class derive: public base
{
//y becomes protected and z becomes
public members of class derive
public:
void showdata()
{
}
};
int main()
{
a.showdata();
return 0;
} //end of program

ACCESS SPECIFIER
Output
x is not accessible
value of y is 2
value of z is 3

Access specifier

More Related Content

What's hot (20)

Similar to Access specifier (20)

More from zindadili (19)

Recently uploaded (20)

Access specifier