Good friend Operate in C++ and courses with Examples | 2023

Introduction

On the planet of object-oriented programming, encapsulation stands as a beacon of safe and structured code creation. C++ additional elevates this precept by introducing a strong but even handed function: the pal perform, which adeptly navigates the high-quality line between sustaining encapsulation and permitting managed entry to class members. This exceptional instrument, which might entry the personal and guarded members of a category, presents programmers the next diploma of flexibility and effectivity in code growth. Within the midst of preserving the sanctity of knowledge encapsulation, it facilitates a seamless interplay between courses, fostering a symbiotic relationship that may improve the general performance of a software program system.

On this tutorial, we’ll learn to create a pal perform in C++ with the assistance of some examples.

Knowledge hiding is a elementary idea in object-oriented programming, and it restricts the entry of personal members from exterior the category.

What’s a Good friend Operate in C++?

A pal perform in C++ is outlined as a perform that may entry personal, protected, and public members of a category.

The pal perform is asserted utilizing the pal key phrase contained in the physique of the category.

Good friend Operate Syntax:

class className {
    ... .. ...
    pal returnType functionName(arguments);
    ... .. ...
}

Through the use of the key phrase, the ‘pal’ compiler understands that the given perform is a pal perform.

We declare a pal perform contained in the physique of a category, whose personal and protecting knowledge must be accessed, beginning with the key phrase pal to entry the information. We use them when we have to function between two completely different courses on the identical time.

What’s Good friend Operate?

Good friend features of the category are granted permission to entry personal and guarded members of the class in C++. They’re outlined globally exterior the category scope. Good friend features aren’t member features of the category. So, what precisely is the pal perform?

A pal perform in C++ is a perform that’s declared exterior a category however is able to accessing the personal and guarded members of the category. There could possibly be conditions in programming whereby we would like two courses to share their members. These members could also be knowledge members, class features or perform templates. In such circumstances, we make the specified perform, a pal to each these courses which can enable accessing personal and guarded knowledge of members of the category.

Usually, non-member features can not entry the personal members of a specific class. As soon as declared as a pal perform, the perform is ready to entry the personal and guarded members of those courses.

Person-defined Operate varieties

Good friend features in C++ have the next varieties

• Operate with no argument and no return worth
• Operate with no argument however with return worth
• Operate with argument however no return worth
• Operate with argument and return worth

Declaration of a pal perform in C++

class class_name
{
   pal data_type function_name(arguments/s); //syntax of pal perform. 
};

Within the above declaration, the key phrase pal precedes the perform. We are able to outline the pal perform anyplace in this system like a traditional C++ perform. A category’s perform definition doesn’t use both the key phrase pal or scope decision operator (: 🙂.

Good friend perform known as as function_name(class_name) and member perform known as as class_name. function_name.

Use of Good friend perform in C++

As mentioned, we require pal features every time now we have to entry the personal or protected members of a category. That is solely the case when we don’t need to use the objects of that class to entry these personal or protected members.

To grasp this higher, allow us to think about two courses: Tokyo and Rio. We would require a perform, metro(), to entry each these courses with none restrictions. With out the pal perform, we would require the item of those courses to entry all of the members. Good friend features in c++ assist us keep away from the situation the place the perform needs to be a member of both of those courses for entry.

C++ perform overloading

Two features can have the identical identify if the quantity and sort of argument handed is completely different. Capabilities which have the identical identify , however have completely different arguements are referred to as Overloading features.

Good friend features are additionally utilized in operator overloading. The binary operator overloading in c++ utilizing the pal perform could be executed as defined beneath.

Binary operator overloading in C++ utilizing Good friend perform

The operator overloading perform precedes a pal key phrase on this method. It additionally declares a perform class scope. The pal operator perform takes 2 parameters in a binary operator. It then varies one parameter in a unary operator.

The perform might be applied exterior the category scope. However, the working and the implementation are the identical because the binary operator perform.

If you wish to construct your data in C++, think about getting licensed. This Introduction to C++ Free Course will show you how to study the required expertise and in addition a certificates on completion that may be added to your social profiles. It’s also possible to take a look at our Full Stack Program by IIT Roorkee.

Traits of Good friend Operate in C++

• The perform isn’t within the ‘scope’ of the category to which it has been declared a pal.
• Good friend performance isn’t restricted to just one class
• Good friend features is usually a member of a category or a perform that’s declared exterior the scope of sophistication.
• It can’t be invoked utilizing the item as it’s not within the scope of that class.
• We are able to invoke it like several regular perform of the category.
• Good friend features have objects as arguments.
• It can not entry the member names immediately and has to make use of dot membership operator and use an object identify with the member identify.
• We are able to declare it both within the ‘public’ or the ‘personal’ half.
• These are among the pal features in C++ traits

Implementing Good friend Capabilities

Good friend Capabilities could be applied in two methods:

A way of one other class:

We declare a pal class once we need to entry the personal knowledge members of a specific class.

A World perform:

A ‘international pal perform’ lets you entry all of the personal and guarded members of the worldwide class declaration.

A easy instance of a C++ pal perform used to print the size of the field.

Code:

#embrace <iostream>
utilizing namespace std;
class Field
{
   personal:
        int size;
   public:
         Field (): size (0) {}
   pal int printLength (Field); //pal perform
};
int printLength (Field b)
{
    b. size +=10;
    return b. size;
}
int essential ()
{
   Field b;
   cout <<” Size of field:” <<printLength (b)<<endl;
    return 0;
}

Output:

           Size of field:10

Easy instance when the perform is pleasant for 2 courses.

Code:

#embrace<iostream>
utilizing namespace std;
class B; //ahead declaration.
class A
{
    int x;
    public:
         void setdata (int i)
           {
              x=i;
           }
    pal void max (A, B); //pal perform.
} ;
class B
{
     int y;
     public:
          void setdata (int i)
            {
               y=i;
            }
     pal void max (A, B);
};
void max (A a, B b)
{
   if (a.x >= b.y)
         std:: cout<< a.x << std::endl;
   else
         std::cout<< b.y << std::endl;
}
  int essential ()
{
   A a;
   B b;
    a. setdata (10);
    b. setdata (20);
    max (a, b);
    return 0;
}

Output:

        20                                         

Within the above instance, max () perform is pleasant to each class A and B, i.e., the max () perform can entry the personal members of two courses.  

Implementing by means of a technique of one other class

A category can not entry the personal members of one other class. Equally, a category can not entry its protected members of a category. We’d like a pal class on this case. 

A pal class is used when we have to entry personal and guarded members of the category during which it has been declared as a pal. Additionally it is attainable to declare just one member perform of one other class to be a pal. 

Declaration of pal class

class class_name
{
      pal class friend_class;// declaring pal class
};
class friend_class
{
};

All features in friend_class are pal features of class_name.

A easy instance of a pal class:

Code:

#embrace <iostream>
utilizing namespace std;
class A
{
   int x=4;
   pal class B; //pal class
};
class B
{
   public:
   void show (A &a)
     {
        cout<<”worth of x is:” <<a.x;
     }
};
int essential ()
{
   A a;
   B b;
   b. show (a);
    return 0;
}

Output:

          worth of x is:4     

Implementing a worldwide perform

Code:

#embrace<iostream>
utilizing namespace std;
class area
{
    int x;
    int y;
    int z;
    public:
    void setdata (int a, int b, int c);
    void show(void);
     pal void operator- (area &s);
};
void area ::setdata (int a, int b, int c)
{
    x=a; y=b; z=c;
}
void area::show(void)
{
    cout<<x<<" "<<y<<" "<<z<<"n";
}
void operator- (area &s)
{
    s.x =- s.x;
    s.y =- s.y;
    s.z =- s.z;
}
int essential ()
{
    area s;
    s. setdata (5,2,9);
    cout<<"s:";
    s. show ();
    -s;
    cout<<"-s:";
    s. show ();
    return 0;
}

Output:

            s: 5 2 9                                                  

      -s: -5 -2 -9 

Within the above instance operator- is the pal perform globally declared on the scope of the category.

Good friend Class in C++

What’s a Good friend class in C++?

Good friend Class is a category that may entry each personal and guarded variables of the category during which it’s declared as a pal, identical to a pal perform. Courses declared as mates to some other class can have all of the member features as pal features to the pal class. Good friend features are used to hyperlink each these courses.

Good friend Class in C++ Syntax:

class One{
<few traces of code right here>
pal class Two;
};
class Two{
<few traces of code>
};

Observe : Except and till we declare, class friendship is neither mutual nor inherited.

To make you perceive intimately:

• If class A is a pal of sophistication B, then class B isn’t a pal of sophistication A.
• Additionally, if class A is a pal of sophistication B, after which class B is a pal of sophistication C, class A isn’t a pal of sophistication C.
• If Base class is a pal of sophistication X, subclass Derived isn’t a pal of sophistication X; and if class X is a pal of sophistication Base, class X isn’t a pal of subclass Derived. 

Benefits of pal perform in C++

• Good friend perform in c++ present a level of freedom within the interface design choice
• A pal perform is used to entry all the personal members of a category.
• You should use a pal perform to bridge two courses by working objects of two completely different courses.
• It will increase the flexibility of overloading operators.
• It enhances encapsulation. Solely the programmer who has entry to the category’s supply code could make a perform pal to that class.
• You could declare a member perform of a category as a pal of one other class.
• It really works symmetrically with all its mates.

Abstract of C++ Good friend Operate

• Though the prototypes for pal features seem within the class definition, mates aren’t members features.
• We are able to declare pal features anyplace in a category definition, that’s both in public, personal or protected sections.
• We are able to do pal declarations anyplace in a category definition, i.e. both in public, personal or protected sections.
• Violates the information hiding precept of courses, so we should always keep away from it as a lot as attainable. You possibly can grant friendship however not take it, i.e., for sophistication B to be a pal of sophistication A, class A should explicitly declare that class B is its pal. The friendship relation is neither symmetric nor transitive. Good friend relationship can’t be inherited.

This brings us to the tip of the weblog on Good friend features in C++. Hope this lets you up-skill your C++ expertise. Additionally, in case you are getting ready for Interviews, take a look at these Interview Questions for C++ to ace it like a professional.

FAQs