friend
keyword.friend
:
|
|
24 |
duplicate
function is a friend of class Rectangle
. Therefore, function duplicate
is able to access the members width
and height
(which are private) of different objects of type Rectangle
. Notice though that neither in the declaration of duplicate
nor in its later use in main
, function duplicate
is considered a member of class Rectangle
. It isn't! It simply has access to its private and protected members without being a member.
|
|
16 |
Rectangle
is a friend of class Square
allowing Rectangle
's member functions to access private and protected members of Square
. More concretely, Rectangle
accesses the member variable Square::side
, which describes the side of the square.Square
. This is necessary because class Rectangle
uses Square
(as a parameter in member convert
), and Square
uses Rectangle
(declaring it a friend). Rectangle
is considered a friend class by Square
, but Square is not considered a friend by Rectangle
. Therefore, the member functions of Rectangle
can access the protected and private members of Square
but not the other way around. Of course, Square
could also be declared friend of Rectangle
, if needed, granting such an access.Polygon
from which we would derive the two other ones: Rectangle
and Triangle
:Polygon
class would contain members that are common for both types of polygon. In our case: width
and height
. And Rectangle
and Triangle
would be its derived classes, with specific features that are different from one type of polygon to the other.A
and we derive a class from it with another member called B
, the derived class will contain both member A
and member B
.
class derived_class_name: public base_class_name
{ /*...*/ };
derived_class_name
is the name of the derived class and base_class_name
is the name of the class on which it is based. The public
access specifier may be replaced by any one of the other access specifiers (protected
or private
). This access specifier limits the most accessible level for the members inherited from the base class: The members with a more accessible level are inherited with this level instead, while the members with an equal or more restrictive access level keep their restrictive level in the derived class.
|
|
20 10 |
Rectangle
and Triangle
each contain members inherited from Polygon
. These are: width
, height
and set_values
.protected
access specifier used in class Polygon
is similar to private
. Its only difference occurs in fact with inheritance: When a class inherits another one, the members of the derived class can access the protected members inherited from the base class, but not its private members.width
and height
as protected
instead of private
, these members are also accessible from the derived classes Rectangle
and Triangle
, instead of just from members of Polygon
. If they were public, they could be accessed just from anywhere.Access | public | protected | private |
---|---|---|---|
members of the same class | yes | yes | yes |
members of derived class | yes | yes | no |
not members | yes | no | no |
main
, from another class or from a function.Rectangle
and Triangle
have the same access permissions as they had in their base class Polygon
:
|
|
public
keyword on each of the derived classes:
|
|
public
keyword after the colon (:
) denotes the most accessible level the members inherited from the class that follows it (in this case Polygon
) will have from the derived class (in this case Rectangle
). Since public
is the most accessible level, by specifying this keyword the derived class will inherit all the members with the same levels they had in the base class.protected
, all public members of the base class are inherited as protected
in the derived class. Conversely, if the most restricting access level is specified (private
), all the base class members are inherited as private
.
|
|
protected
as the less restrictive access level for the members of Daughter
that it inherited from mother. That is, all members that were public
in Mother
would become protected
in Daughter
. Of course, this would not restrict Daughter
from declaring its own public members. That less restrictive access level is only set for the members inherited from Mother
.class
and public for those declared with struct
.
derived_constructor_name (parameters) : base_constructor_name (parameters) {...}
|
|
Mother: no parameters Daughter: int parameter Mother: int parameter Son: int parameter |
Mother
's constructor is called when a new Daughter
object is created and which when it is a Son
object. The difference is due to the different constructor declarations of Daughter
and Son
:
|
|
Output
, and we wanted our classes Rectangle
and Triangle
to also inherit its members in addition to those of Polygon
we could write:
|
|
|
|
20 10 |
Previous: Special members | Index | Next: Polymorphism |