Skip to main content

Friends of C++

Friend function
Remember that a member which is not public (Private and protected )  can not be accessed from outside the class. 

Three are some situations where you may need to access these. Keyword friend  is used for this. A friend functions and classes can access all members of a class. 

This concept is controversial. People say friend concept violates data encapsulation 

A friend function is a non-member function but still can access all the members of a class including private members. Such a function is declared within class body with the prefix "friend"

class Number
{
 int num;
public:
 Number(int m){/*code*/}
 friend void printNum(Number ob);/*friend function*/
};

void printNum(Number obj)
{
 cout<<obj.num<<"endl";
}

printNum() is not member of class Number. But it can still access all members including private members, because it is a friend.

Friend class

An object of a friend class can access all the members of a class.

#include<iostream>
using std::cout;
class A;
class Number
{
 int num;
public:
 Number(int a):num(a){};
 friend class A;
};
class A
{
public:
 void printNumber(Number ob){cout<<ob.num;}
 int getNumber(Number ob){return ob.num;}
};
int main()
{
 A ob1;
 Number ob2(10);
 ob1.printNumber(ob2); 
}

Output
10

ob1 - is an object of A class. So it should not be able to access private members of Number class. But as A class is declared as a friend of Number class. So printNumber() and getNumber() functions of A class can access private data num of Number class.

Declaration of class A above class Number is called forward declaration. You need to use forward declaration for friend class.


Comments

Popular posts from this blog

Polymorphism

You hear the term Polymorphism too frequently with object oriented languages. Along with Inheritance and Encapsulation, polymorphism is one of the corner stones of object oriented design. What is Polymorphism, exactly? Polymorphism is a mechanism by which you provide single interface for multiple methods. (poly - many, morph - form). In C++, polymorphism can be compile time or run-time. Compile time polymorphism is provided with the help of overloaded operators/functions and templates. Run time polymorphism is provided with the help of virtual functions and late binding. Late Binding: Connecting a function call to function body is called binding. Most functions use early binding where this binding happens before the program is run - during compile time. This is also called static binding. Late binding (also called dynamic binding)  is when a function call is connected to function body at run time. This is done after looking at the type of the object. Late binding is ach

Operator Overloading

What is operator overloading ? Operator overloading is the process of customizing C++ operators for operands of user defined types.   When you have two objects of a class- num1 and num2 , you can write a function to add them such as  ans = add(num1,num2); That does not look neither simple nor intuitive. You would prefer to write      ans = num1+num2; as you would write expressions for basic data types like integers, floats etc.    This can be done using Operator overloading. Operator overloading lets you write such statements. That is, it lets you call your functions on objects using  +, - ,* etc.    + operator will call addition function on the object (when you write op. overloading function for +). * will call multiply on objects etc. Names of overloaded operator functions start with keyword operator followed by  symbol of the operator. e.g. +, - etc. Unary operator functions take 0 parameters for members. The operand for these function is the object cal

Constant members of a Class

A constant  is a value which can not be modified. As in C, we can have literal constants using #define and we can have enums and we can define a variable to be const .  Let us look at const variables here. By declaring a variable as const , we ensure that it is not modified accidentally. Any modification to a constant will give a compilation error. A const should always be initialized while defining. In the program below,  assignment to pi gives a compiler error because pi is defined as const and code is trying to modify this. int main () { const float pi = 22.0/7 ; int radius = 12 ; radius ++ ; /*ok*/ pi = 3.14 ; /*error*/ }   Constant parameters to functions Even function parameters can be const ant. We have earlier discussed that making a reference parameter as constant will avoid the function from accidentally modifying the argument. void printnum ( int & n) { cout << n ++ ; } void printnum2 ( const int & n) { cout <&l