What is a C plus plus program to demonstrate the use of access specifiers?

Answer 1

Access specifiers apply to class and struct data types only. If a member is declared before an access specifier is declared, the default access is implied. Once an access specifier is declared, that specifier remains in force until another specifier is declared. Specifiers can be declared in any order and may be repeated as often as required.

The following demonstrates usage and purpose of each specifier.

class X {

friend void f(); // Friends can be declared anywhere.

private: // The default access specifier for class types (implied if omitted).

int a; // Only accessible to members of X and to friends of X.

protected:

int b; // Same as private, also accessible to derivatives of X.

public:

int c; // Accessible to any code where X is visible.

};

struct Y { friend void f(); // Friends can be declared anywhere.

public: // The default access specifier for struct types (implied if omitted).

int a; // Accessible to any code where Y is visible.

protected:

int b; // Same as private, also accessible to derivatives of Y.

private:

int c; // Only accessible to members of Y and friends of Y.

};

struct Z : X

{};

void f()

{

X x;

x.a = 42; // OK! X::a is private and f is a friend of X.

x.b = 42; // OK! X::b is protected and f is a friend of X.

x.c = 42; // OK! X::c is public and X is visible to f.

Y y;

y.a = 42; // OK! Y::a is public and Y is visible to f.

y.b = 42; // OK! Y::b is protected and f is a friend of Y.

y.c = 42; // OK! Y::c is private and f is a friend of Y.

Z z;

z.a = 42; // OK! Z::Y::a is public and Z is visible to f.

z.b = 42; // OK! Z::Y::b is protected and f is a friend of Y.

z.c = 42; // OK! Z::Y::c is private and f is a friend of Y.

}

int main()

{

X x;

x.a = 42; // error! X::a is private and main is not a friend of X.

x.b = 42; // error! X::b is protected and main does not derive from X.

x.c = 42; // OK! X::c is public and is X is visible to main.

Y y;

y.a = 42; // OK! Y::a is public and is Y is visible to main.

y.b = 42; // error! Y::b is protected and main does not derive from Y.

y.c = 42; // error! Y::c is private and main is not a friend of Y.

Z z;

z.a = 42; // OK! Z::Y::a is public and Z is visible to main.

z.b = 42; // error! Z::Y::b is protected and main is not derived from Y.

z.c = 42; // error! Z::Y::c is private and main is not a friend of Y.

}

Answer 2

Public, protected and private. Private access limits member exposure to the class members and to friends of the class. Protected access is the same as private but also allows access to derived classes. Public access is unrestricted.

Answer 3

The C++ access specifiers are public, protected and private. Access specifiers allow class designers to limit the exposure of their class members. Private members are only accessible to other members of the class as well as friends of the class. Protected members are the same as private members but are also accessible to derivatives of the class. Public members are fully accessible.

For class data types, the default access is private. For struct data types, the default is public. Other than that, there is no difference between a struct and a class.

class A {

int a;

protected:

int b;

public:

int c;

};

In the above example, A::a is private because private is the default access. A::b is protected because it is in a protected section. For the same reason, A::c is public.

Although the default access is often implied, most programmers will explicitly state the access, even if the default access would have applied anyway. Thus class A may also be declared as follows:

class A {

private:

int a;

protected:

int b;

public:

int c;

};

Access specifiers can also be declared in any order, and may be repeated as often as is required. Note also that access specifiers can be applied to member methods (including constructors and operators) as well as member data, but they do not apply to friend declarations (friends can be declared in any section).

Access specifiers can also be used to determine the visibility of base class members with regards to derived classes.

class B : A {};

Again, most programmers will specify the visibility mode even if the default would apply anyway:

class B : private A {};

In the above example, B inherits from A, and therefore inherits both b and c from A (private members can never be inherited). However, because visibility is private, both B::b and B::c are private.

class C : protected A {};

In the above example, C also inherits b and c, but C::c is protected (C::b remains protected).

class D : public A {};

In the above example, D::b remains protected while D::c remains public.

Sometimes it may be desirable to alter the access of an individual base class member. To achieve this you simply redeclare the base class member with the required access:

class E : public A

{

protected:

int A::c;

};

In the above example, E is effectively the same as B (where both b and c are protected). However, if A had other public members they would remain public to E.

Note that you cannot increase access to base class members, you can only reduce or leave it the same.

Answer 4

Access specifiers determine the accessibility of class members. Private class members are accessible to the class and to friends of the class. Protected class members are the same as private but are also accessible to derivatives of the class. Public class members are fully accessible. If no access specifier is specified, private access is implied when declaring class members, while public access is implied when declaring struct members.

Answer 5

Private, protected and public. These keywords are also used to declare the type of inheritance, demoting anything with greater access in the base class to the access specified by the inheritance in the derived class. E.g., protected inheritance demotes public members of the base class to protected members of the derived class, while private inheritance demotes protected and public members of the base class to private members of the derived class.

Answer 6

There are three: private, protected and public. Private members are only accessible to the class members and to friends of the class. Protected members are the same as private members but are also accessible to derivatives of the class. Public members are fully-accessible, both inside and outside the class.

Answer 7

An Access Specifier or an Access Modifier is a keyword that determines the visibility of that entity under consideration. The different access modifiers in Java are:

• Public
• Private
• Protected
• Default

Public is the least restrictive access specifier whereas private is the most restrictive

Answer 8

Private, unless the class is a struct, in which case the default is public.