Good friend Perform 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 characteristic: the pal perform, which adeptly navigates the advantageous line between sustaining encapsulation and permitting managed entry to class members. This outstanding device, which might entry the personal and guarded members of a category, gives programmers the next diploma of flexibility and effectivity in code growth. Within the midst of preserving the sanctity of information 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 are going to discover ways to create a pal perform in C++ with the assistance of some examples.

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

What’s a Good friend Perform 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 said utilizing the pal key phrase contained in the physique of the category.

Good friend Perform Syntax:

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

By utilizing 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 information must be accessed, beginning with the key phrase pal to entry the info. We use them when we have to function between two totally different courses on the identical time.

What’s Good friend Perform?

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

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

Typically, non-member features can’t entry the personal members of a selected class. As soon as declared as a pal perform, the perform is ready to entry the personal and guarded members of those courses.

Consumer-defined Perform varieties

Good friend features in C++ have the next varieties

• Perform with no argument and no return worth
• Perform with no argument however with return worth
• Perform with argument however no return worth
• Perform 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 is known as as function_name(class_name) and member perform is known as as class_name. function_name.

Use of Good friend perform in C++

As mentioned, we require pal features each 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 know this higher, allow us to take into account 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 thing 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 title if the quantity and kind of argument handed is totally different. Capabilities which have the identical title , however have totally 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 may be finished 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 will likely be applied outdoors 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++, take into account getting licensed. This Introduction to C++ Free Course will enable you to study the required expertise and likewise a certificates on completion that may be added to your social profiles. You too can try our Full Stack Program by IIT Roorkee.

Traits of Good friend Perform in C++

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

Implementing Good friend Capabilities

Good friend Capabilities may be applied in two methods:

A way of one other class:

We declare a pal class after we need to entry the private information members of a selected class.

A International perform:

A ‘world pal perform’ permits you to 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:

#embody <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 principal ()
{
   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:

#embody<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 principal ()
{
   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 a technique of one other class

A category can’t entry the personal members of one other class. Equally, a category can’t 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 through which it has been declared as a pal. It is usually 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:

#embody <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 principal ()
{
   A a;
   B b;
   b. show (a);
    return 0;
}

Output:

          worth of x is:4     

Implementing a worldwide perform

Code:

#embody<iostream>
utilizing namespace std;
class house
{
    int x;
    int y;
    int z;
    public:
    void setdata (int a, int b, int c);
    void show(void);
     pal void operator- (house &s);
};
void house ::setdata (int a, int b, int c)
{
    x=a; y=b; z=c;
}
void house::show(void)
{
    cout<<x<<" "<<y<<" "<<z<<"n";
}
void operator- (house &s)
{
    s.x =- s.x;
    s.y =- s.y;
    s.z =- s.z;
}
int principal ()
{
    house 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 through which it’s declared as a pal, identical to a pal perform. Courses declared as buddies to every other class may 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 strains of code right here>
pal class Two;
};
class Two{
<few strains 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 will not be 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 will not be a pal of sophistication C.
• If Base class is a pal of sophistication X, subclass Derived will not be a pal of sophistication X; and if class X is a pal of sophistication Base, class X will not be 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 possibility
• A pal perform is used to entry all the private members of a category.
• You should use a pal perform to bridge two courses by working objects of two totally 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 might declare a member perform of a category as a pal of one other class.
• It really works symmetrically with all its buddies.

Abstract of C++ Good friend Perform

• Regardless that the prototypes for pal features seem within the class definition, buddies usually are not 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 info hiding precept of courses, so we must 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 top of the weblog on Good friend features in C++. Hope this lets you up-skill your C++ expertise. Additionally, if you’re getting ready for Interviews, try these Interview Questions for C++ to ace it like a professional.

FAQs