Introduktion till vänsfunktion i C ++
En unik funktion i C ++ -programmet är att det använder inkapsling för att hålla informationen lindad tillsammans med alla dess driftsfunktioner för att utgöra en enskild enhet. Detta säkerställer att den specifika informationen endast kan nås av de uppgifter som fungerar på den och inte av någon annan uppgift utanför denna klass. Därför använder vi denna specifika funktion som kallas "vän" -funktionen i fall där den externa klassen kan behöva få åtkomst till denna data. Vi vet att genom att använda nyckelord som "skyddad" och "privat" kan vi inte få åtkomst till dessa data utanför dess metod. Men för realtidsansökan finns det många fall där vi kan behöva samma privata / skyddade data och att använda den redan deklarerade är alltid mer att föredra än att skapa den många gånger. Låt oss se hur vi förklarar och använder en vänsfunktion i C ++ i den här artikeln.
En vänfunktion medan deklareras föregås av nyckelordet "vän" som visas här:
Syntax :
class (
private
protected
friend (arguments list);
)
returnDatatype functionName(arguments list)(
//function from which protected and private keywords
//can be accessed from as this is a friend method of className
)class (
private
protected
friend (arguments list);
)
returnDatatype functionName(arguments list)(
//function from which protected and private keywords
//can be accessed from as this is a friend method of className
)
Som visas i ovanstående kod måste vänfunktionen deklareras i samma klass där det skyddade eller privata nyckelordet har deklarerats för att dessa data ska vara tillgängliga utanför klassen. Denna funktion tillåts att deklareras var som helst i hela programmet precis som en vanlig C ++ -metod. Funktionsdefinitionen kräver inte nyckelord som vänner eller några operatörer för omfattningsupplösning.
Exempel på Friend-funktion i C ++ -program
Låt oss kolla in vänfunktionens arbete lite bättre genom att ta några exempel nedan.
Exempel 1
Koda:
/* C++ program which exhibits the working of friend function.*/
#include
using namespace std;
class Weight
(
private:
int kilo;
public:
Weight(): kilo(0) ( )
//Declaration of a friend function
friend int addWeight(Weight);
);
// Defining a friend function
int addWeight(Weight w)
(
//accessing private data from non-member function
w.kilo += 17;
return w.kilo;
)
int main()
(
Weight W;
cout<<"Weight: "<< addWeight(W);
return 0;
)
Produktion:
Här är vänfunktionen addWeight () -metoden som deklareras inom viktklassen. Kilo är det privata nyckelord som deklareras inom viktmetoden som sedan nås från addWeight-funktionen på grund av det. Detta exempel var bara för att visa den grundläggande användningen av en vänsfunktion även om det inte finns någon realtidsanvändning här. Låt oss nu djupt dyka in i några meningsfulla exempel.
Exempel 2
Koda:
#include
using namespace std;
// Forward declaration
class SecondClass;
class FirstClass (
private:
int first_num;
public:
FirstClass(): first_num(12) ( )
// Declaring a friend function
friend int divide(FirstClass, SecondClass);
);
class SecondClass (
private:
int sec_num;
public:
SecondClass(): sec_num(4) ( )
// Another friend declaration
friend int divide(FirstClass, SecondClass);
);
// Function divide() is the friend function of classes FirstClass and SecondClass
// that accesses the member variables first_num and sec_num
int divide(FirstClass fnum, SecondClass snum)
(
return (fnum.first_num / snum.sec_num);
)
int main()
(
FirstClass fnum;
SecondClass snum;
cout<<"The value got by dividing first by second number: "<< divide(fnum, snum);
return 0;
)
Produktion:
I det här exemplet har både klasserna FirstClass och SecondClass uppdelat () som deklarerats som en vänfunktion. Därför kan denna funktion få åtkomst till de privata variabeldata från båda klassen. Här används funktionen divide () för att lägga till privata variabler first_num och sec_num för två objekt fnum och snum och returnerar dess värde till huvudmetoden.
För att detta ska fungera korrekt måste en framåtdeklaration för SecondClass göras som visas i koden eftersom SecondClass refereras inom FirstClass med programmet:
friend int divide(FirstClass, SecondClass);
Vänklass: Det finns en vänskurs precis som vänfunktionen. Vänsklassen kan också komma åt både privata och skyddade variabler i klassen eftersom det är en vän till den.
Syntax :
class One(
friend class Two;
);
class Two(
);class One(
friend class Two;
);
class Two(
);class One(
friend class Two;
);
class Two(
);
Som visas ovan är klass två en vän till klass ett. Därför kan klass två få åtkomst till privata och skyddade variabler i klass en. Men klass en kan inte få åtkomst till skyddade eller privata variabler i klass två eftersom detta inte är en ömsesidig vänskap. För ömsesidig vänskap bör vi förklara det uttryckligen. På samma sätt ärvs inte denna vänskap i klassen vilket innebär att klass två inte ska vara en vän till underklasserna i klass en trots att det är en vän till klass en.
Exempel 3
Koda:
#include
#include
using namespace std;
class Perimeter(
int len, brd, perimeter, temp;
public:
Perimeter(int len, int brd):len(len), brd(brd)
()
void calcPerimeter()(
temp = len + brd;
perimeter = 2 * temp;
)
friend class printClass;
);
class printClass(
public:
void printPerimeter(Perimeter a)(
cout<<"Perimeter = "< )
);
int main()(
Perimeter a(10, 15);
a.calcPerimeter();
printClass p;
p.printPerimeter(a);
return 0;
)#include
#include
using namespace std;
class Perimeter(
int len, brd, perimeter, temp;
public:
Perimeter(int len, int brd):len(len), brd(brd)
()
void calcPerimeter()(
temp = len + brd;
perimeter = 2 * temp;
)
friend class printClass;
);
class printClass(
public:
void printPerimeter(Perimeter a)(
cout<<"Perimeter = "< )
);
int main()(
Perimeter a(10, 15);
a.calcPerimeter();
printClass p;
p.printPerimeter(a);
return 0;
)
Produktion:
I den här koden har vi två klasser: Omkretsklass som hittar omkretsen med längd- och breddvärdena. Variabler len, brd, perimeter och temp är alla privata variabler i klassomkretsen. Därför måste vi göra printClass till en vän till Perimeter-klassen. Detta printClass använder Perimeter-värdet beräknat i funktionen calcPerimeter () i klassen Perimeter. Eftersom de alla är privata medlemmar måste vi göra printPerimeter till en vän till Perimeter-klassen. När detta är gjort måste vi skapa ett objekt i huvudklassen för att beräkna omkretsen och skicka detta objekt till klassen printPerimeter för att visa omkretsen.
Funktioner i Friend Function i C ++
- Metoden och klassen till vilken den har förklarats som en vän behöver inte vara densamma.
- Eftersom det inte omfattas av respektive klass, kan det inte ringas med sitt objekt.
- Det kan också kallas precis som en vanlig metod även utan att använda objektet.
- Den kan bara få åtkomst till medlemsnamnen genom att använda sitt objektnamn och dot-medlemskapsoperatör tillsammans med dess medlemsnamn.
- Det finns ingen begränsning eftersom det är tillåtet att deklareras i varken privat eller offentlig del.
Slutsats
Med tanke på alla ovan nämnda funktioner och exemplen på vänfunktion i C ++ måste man också vara försiktig när man använder en väns funktioner med många funktioner och externa klasser eftersom det kan minska vikten av inkapsling av olika klasser i objektorienterad programmering. Därför kan det vara både en välsignelse och en bane för programmeraren.
Rekommenderad artikel
Detta är en guide till Friend Function i C ++. Här diskuterar vi funktionen Introduktion till vän i C ++ och dess exempel tillsammans med kodimplementering och utdata. du kan också gå igenom våra föreslagna artiklar för att lära dig mer -
- Rekursiv funktion i C ++ (exempel)
- Topp 11 funktioner i C ++
- Machine Learning C ++ Library
- Hashing-funktion i C med typer
- Hashing-funktion i PHP med Syntax