What are the different mechanism for protecting data from external user of the class in c plus plus?

Answer 1

There is only one mechanism for protecting data in C++: declare the data private. This ensures that only the class and friends of the class have unrestricted access to the data.

Although protected access sounds more appropriate with regards protecting data, this is not the case at all. Protected data has the same restrictions as private data but also exposes the data to derivatives of the class. This means that any user can derive a class from your class and thus gain unrestricted access to the so-called "protected" data.

Although you could declare your class final to prevent users from inheriting from your class, it makes no sense to use protected data in a final class. Although the language would permit such a declaration, the two are mutually exclusive.

Note that, unlike Java, C++ has no 'final' keyword (the C# equivalent is 'sealed'). However, we can make use of existing mechanisms to achieve the same end. Consider the following:

class A;

class B

{

friend class A;

private:

B () {}

};

class A : public virtual B {};

In the above example, class A is final. To understand why, keep in mind that virtual inheritance guarantees that the most-derived class must be able to call the least-derived class constructor first. In this case, the least-derived class B has a private constructor that is only accessible to friend class A. Thus A must always be the most-derived class. In other words, only A can inherit from B and no other class can inherit from A.

Since A is final, it makes no sense to declare any protected members within A as no class can inherit them. Also, it makes no sense to declare protected members in B since A automatically inherits private members of B by virtue of being a friend class and is the only class that can inherit from B in any case.

As a general rule of thumb, protected data should be avoided whenever possible. Data should either be private or public. There is rarely the need for a derived class to inherit data, bearing in mind that this could undermine the encapsulation of your class.

Protected methods are generally OK if you expect your class to be inherited by many classes for which you may not have any control over (an open system), but where those derivatives require access to internal methods that would otherwise be declared private. The only alternative would be to declare those derivatives as friend classes, which is only feasible when you have full control over those derivatives (a closed system). In that case it may prove simpler to use final mechanics instead.