|
C++ Programming Tutorials
Basics of C++
Structure of a
program
Variables
Data types
Constants
Operators
Basic Input/output
Control Structures
Control Structures
Functions (I)
Functions (II)
Compound Data Types
Arrays
Character Sequences
Pointers
Dynamic Memory
Data Structures
Other Data Types
Object Oriented Programming
Classes [I]
Classes [II]
Friendship & Inheritance
Polymorphism
Advanced Concepts
Templates
Namespaces
Exceptions
Type Casting
Preprocessor Directives
C++ Standard Library
Input/output with Files
Soft Skills
Communication Skills
Leadership Skills
.........More
|
|
C++ Programming Tutorials
Friendship and
inheritance
Friend functions
In principle, private and protected members of a class cannot be
accessed from outside the same class in which they are declared.
However, this rule does not affect friends.
Friends are functions or classes declared as such.
If we want to declare an external function as friend of a class, thus
allowing this function to have access to the private and protected
members of this class, we do it by declaring a prototype of this
external function within the class, and preceding it with the keyword
friend:
// friend functions
#include <iostream>
using namespace std;
class CRectangle {
int width, height;
public:
void set_values (int, int);
int area () {return (width * height);}
friend CRectangle duplicate (CRectangle);
};
void CRectangle::set_values (int a, int b) {
width = a;
height = b;
}
CRectangle duplicate (CRectangle rectparam)
{
CRectangle rectres;
rectres.width = rectparam.width*2;
rectres.height = rectparam.height*2;
return (rectres);
}
int main () {
CRectangle rect, rectb;
rect.set_values (2,3);
rectb = duplicate (rect);
cout << rectb.area();
return 0;
} |
24
|
The duplicate function is a friend of CRectangle. From within
that function we have been able to access the members width and height of
different objects of type CRectangle, which are private members. Notice that
neither in the declaration of duplicate() nor in its later use in main() have we
considered duplicate a member of class CRectangle. It isn't! It simply has
access to its private and protected members without being a member.
The friend functions can serve, for example, to conduct operations between two
different classes. Generally, the use of friend functions is out of an
object-oriented programming methodology, so whenever possible it is better to
use members of the same class to perform operations with them. Such as in the
previous example, it would have been shorter to integrate duplicate() within the
class CRectangle.
Friend classes
Just as we have the possibility to define a friend function, we can also define
a class as friend of another one, granting that second class access to the
protected and private members of the first one.
// friend class
#include <iostream>
using namespace std;
class CSquare;
class CRectangle {
int width, height;
public:
int area ()
{return (width * height);}
void convert (CSquare a);
};
class CSquare {
private:
int side;
public:
void set_side (int a)
{side=a;}
friend class CRectangle;
};
void CRectangle::convert (CSquare a) {
width = a.side;
height = a.side;
}
int main () {
CSquare sqr;
CRectangle rect;
sqr.set_side(4);
rect.convert(sqr);
cout << rect.area();
return 0;
} |
16
|
In this example, we have declared CRectangle as a friend of
CSquare so that CRectangle member functions could have access to the protected
and private members of CSquare, more concretely to CSquare::side, which
describes the side width of the square.
You may also see something new at the beginning of the program: an empty
declaration of class CSquare. This is necessary because within the declaration
of CRectangle we refer to CSquare (as a parameter in convert()). The definition
of CSquare is included later, so if we did not include a previous empty
declaration for CSquare this class would not be visible from within the
definition of CRectangle.
Consider that friendships are not corresponded if we do not explicitly specify
so. In our example, CRectangle is considered as a friend class by CSquare, but
CRectangle does not consider CSquare to be a friend, so CRectangle can access
the protected and private members of CSquare but not the reverse way. Of course,
we could have declared also CSquare as friend of CRectangle if we wanted to.
Another property of friendships is that they are not transitive: The friend of a
friend is not considered to be a friend unless explicitly specified.
NEXT >>
Inheritance between classes
Have a Question ?
post your questions here. It
will be answered as soon as possible.
Check
C Aptitude Questions
for more C Aptitude Interview Questions with Answers
Check
C Interview Questions
for more C Interview Questions with Answers.
|