Een functie is een reeks instructies die invoer nodig heeft, een specifieke berekening uitvoert, en produceert output. Het idee is om sommige vaak of herhaaldelijk te plaatsen samen taken uitvoeren om een functie zodat we in plaats van steeds opnieuw dezelfde code te schrijven voor verschillende invoer, deze functie kunnen aanroepen.
Simpel gezegd is een functie een codeblok dat alleen wordt uitgevoerd als het wordt aangeroepen.
Syntaxis:
Syntaxis van functie
Voorbeeld:
C++
// C++ Program to demonstrate working of a function> #include> using> namespace> std;> // Following function that takes two parameters 'x' and 'y'> // as input and returns max of two input numbers> int> max(>int> x,>int> y)> {> >if> (x>y)> >return> x;> >else> >return> y;> }> // main function that doesn't receive any parameter and> // returns integer> int> main()> {> >int> a = 10, b = 20;> >// Calling above function to find max of 'a' and 'b'> >int> m = max(a, b);> >cout <<>'m is '> << m;> >return> 0;> }> |
>
>Uitvoer
m is 20>
Tijdcomplexiteit: O(1)
Ruimtecomplexiteit: O(1)
Waarom hebben we functies nodig?
- Functies helpen ons daarbij het verminderen van coderedundantie . Als functionaliteit op meerdere plaatsen in software wordt uitgevoerd, creëren we, in plaats van steeds opnieuw dezelfde code te schrijven, een functie en roepen deze overal aan. Dit helpt ook bij het onderhoud, omdat we slechts op één plek wijzigingen hoeven door te voeren als we in de toekomst wijzigingen in de functionaliteit aanbrengen.
- Functies maken code modulair . Beschouw een groot bestand met veel regels code. Het wordt heel eenvoudig om de code te lezen en te gebruiken als de code in functies is verdeeld.
- Functies bieden abstractie . We kunnen bijvoorbeeld bibliotheekfuncties gebruiken zonder ons zorgen te hoeven maken over hun interne werk.
Functieverklaring
Een functiedeclaratie vertelt de compiler over het aantal parameters, gegevenstypen van parameters en het geretourneerde type functie. Het schrijven van parameternamen in de functiedeclaratie is optioneel, maar het is noodzakelijk om ze in de definitie op te nemen. Hieronder ziet u een voorbeeld van functiedeclaraties. (parameternamen zijn niet aanwezig in de onderstaande declaraties)
Functieverklaring
Voorbeeld:
C++
// C++ Program to show function that takes> // two integers as parameters and returns> // an integer> int> max(>int>,>int>);> // A function that takes an int> // pointer and an int variable> // as parameters and returns> // a pointer of type int> int>* swap(>int>*,>int>);> // A function that takes> // a char as parameter and> // returns a reference variable> char>* call(>char> b);> // A function that takes a> // char and an int as parameters> // and returns an integer> int> fun(>char>,>int>);> |
>
>
Soorten functies
Soorten functies in C++
Door de gebruiker gedefinieerde functie
Door de gebruiker gedefinieerde functies zijn door de gebruiker/klant gedefinieerde codeblokken die speciaal zijn aangepast om de complexiteit van grote programma's te verminderen. Ze zijn ook algemeen bekend als op maat gemaakte functies die alleen zijn gebouwd om te voldoen aan de omstandigheden waarin de gebruiker met problemen wordt geconfronteerd, terwijl de complexiteit van het hele programma wordt verminderd.
Bibliotheekfunctie
Bibliotheekfuncties worden ook wel genoemd ingebouwde functies . Deze functies maken deel uit van een compilerpakket dat al is gedefinieerd en bestaat uit een speciale functie met speciale en verschillende betekenissen. Ingebouwde functies geven ons een voorsprong omdat we ze direct kunnen gebruiken zonder ze te definiëren, terwijl we bij de door de gebruiker gedefinieerde functie een functie moeten declareren en definiëren voordat we ze kunnen gebruiken.
Bijvoorbeeld: sqrt(), setw(), strcat(), enz.
Parameter doorgeven aan functies
De parameters die aan de functie worden doorgegeven, worden aangeroepen werkelijke parameters . In het onderstaande programma zijn 5 en 10 bijvoorbeeld werkelijke parameters.
De door de functie ontvangen parameters worden aangeroepen formele parameters . In het bovenstaande programma zijn x en y bijvoorbeeld formele parameters.
Formele parameter en werkelijke parameter
Er zijn twee populairste manieren om parameters door te geven:
- Pass-by-waarde: Bij deze methode voor het doorgeven van parameters worden waarden van werkelijke parameters gekopieerd naar de formele parameters van de functie. De feitelijke en formele parameters worden op verschillende geheugenlocaties opgeslagen, zodat eventuele wijzigingen in de functies niet worden weerspiegeld in de werkelijke parameters van de beller.
- Passeer referentie: Zowel feitelijke als formele parameters verwijzen naar dezelfde locaties, dus alle wijzigingen die binnen de functie worden aangebracht, worden weerspiegeld in de werkelijke parameters van de aanroeper.
Functiedefinitie
Geef waarde door wordt gebruikt wanneer de waarde van x niet wordt gewijzigd met behulp van de functie fun().
C++
tekenreeks als een array
// C++ Program to demonstrate function definition> #include> using> namespace> std;> void> fun(>int> x)> {> >// definition of> >// function> >x = 30;> }> int> main()> {> >int> x = 20;> >fun(x);> >cout <<>'x = '> << x;> >return> 0;> }> |
>
>Uitvoer
x = 20>
Tijdcomplexiteit: O(1)
Ruimtecomplexiteit: O(1)
Functies met behulp van aanwijzers
De functie fun() verwacht een pointer ptr naar een geheel getal (of een adres van een geheel getal). Het wijzigt de waarde op het adres ptr. De dereferentie-operator * wordt gebruikt om toegang te krijgen tot de waarde op een adres. In de instructie ‘*ptr = 30’ wordt de waarde bij adres ptr gewijzigd in 30. De adresoperator & wordt gebruikt om het adres van een variabele van elk gegevenstype te verkrijgen. In de functieaanroepopdracht ‘fun(&x)’ wordt het adres van x doorgegeven zodat x kan worden gewijzigd met behulp van zijn adres.
C++
// C++ Program to demonstrate working of> // function using pointers> #include> using> namespace> std;> void> fun(>int>* ptr) { *ptr = 30; }> int> main()> {> >int> x = 20;> >fun(&x);> >cout <<>'x = '> << x;> >return> 0;> }> |
>
>Uitvoer
x = 30>
Tijdcomplexiteit: O(1)
Ruimtecomplexiteit: O(1)
Verschil tussen bellen op waarde en bellen op referentie in C++
| Bellen op waarde | Bellen via referentie |
|---|---|
| Een kopie van de waarde wordt doorgegeven aan de functie | Er wordt een waardeadres aan de functie doorgegeven |
| Wijzigingen die binnen de functie zijn aangebracht, zijn dat niet weerspiegeld in andere functies | Wijzigingen die binnen de functie zijn aangebracht, worden weerspiegeld Ook buiten de functie |
| Daadwerkelijke en formele argumenten zullen worden gecreëerd op andere geheugenlocatie | Daadwerkelijke en formele argumenten zullen worden gecreëerd op dezelfde geheugenlocatie. |
Punten om te onthouden over functies in C++
1. De meeste C++-programma's hebben een functie genaamd main() die door het besturingssysteem wordt aangeroepen wanneer een gebruiker het programma uitvoert.
2. Elke functie heeft een retourtype. Als een functie geen waarde retourneert, wordt void als retourtype gebruikt. Bovendien kunnen we, als het return-type van de functie ongeldig is, nog steeds de return-instructie gebruiken in de hoofdtekst van de functiedefinitie door er geen enkele constante, variabele, enz. mee op te geven, door alleen de 'return;'-instructie te vermelden die dat wel zou doen symboliseren de beëindiging van de functie zoals hieronder weergegeven:
C++
void> function name(>int> a)> {> >.......>// Function Body> >return>;>// Function execution would get terminated> }> |
>
Java abstracte klasse
>
3. Om een functie te declareren die alleen kan worden aangeroepen zonder enige parameter, moeten we gebruiken leegte plezier (leegte) . Even terzijde: in C++ betekent een lege lijst dat een functie alleen kan worden aangeroepen zonder enige parameter. In C++ zijn zowel void fun() als void fun(void) hetzelfde.
Hoofdfunctie
De hoofdfunctie is een speciale functie. Elk C++-programma moet een functie bevatten met de naam main. Het dient als toegangspunt voor het programma. De computer begint de code uit te voeren vanaf het begin van de hoofdfunctie.
Soorten hoofdfuncties
1. Zonder parameters:
CPP
// Without Parameters> int> main() { ...>return> 0; }> |
>
>
2. Met parameters:
CPP
// With Parameters> int> main(>int> argc,>char>*>const> argv[]) { ...>return> 0; }> |
>
>
De reden voor het hebben van de parameteroptie voor de hoofdfunctie is om invoer vanaf de opdrachtregel mogelijk te maken. Wanneer u de hoofdfunctie met parameters gebruikt, wordt elke groep tekens (gescheiden door een spatie) na de programmanaam opgeslagen als elementen in een array met de naam argv .
Omdat de hoofdfunctie het retourtype heeft van int , moet de programmeur altijd een return-instructie in de code hebben. Het nummer dat wordt geretourneerd, wordt gebruikt om het oproepende programma te informeren over het resultaat van de uitvoering van het programma. Het retourneren van 0 geeft aan dat er geen problemen waren.
C++ Recursie
Wanneer de functie binnen dezelfde functie wordt aangeroepen, staat dit in C++ bekend als recursie. De functie die dezelfde functie aanroept, staat bekend als recursieve functie.
Een functie die zichzelf aanroept en na het aanroepen van de functie geen enkele taak uitvoert, staat bekend als staartrecursie. Bij staartrecursie noemen we over het algemeen dezelfde functie met de return-instructie.
Syntaxis:
C++
recursionfunction()> {> >recursionfunction();>// calling self function> }> |
>
>
Meer weten zie Dit artikel .
C++ Array doorgeven aan functie
In C++ kunnen we, om de arraylogica te hergebruiken, een functie maken. Om een array door te geven aan een functie in C++, hoeven we alleen de arraynaam op te geven.
function_name(array_name[]); //passing array to function>
Voorbeeld: Druk het minimumaantal in de gegeven array af.
python soort tupel
C++
#include> using> namespace> std;> void> printMin(>int> arr[5]);> int> main()> {> >int> ar[5] = { 30, 10, 20, 40, 50 };> >printMin(ar);>// passing array to function> }> void> printMin(>int> arr[5])> {> >int> min = arr[0];> >for> (>int> i = 0; i <5; i++) {> >if> (min>arr[i]) {> >min = arr[i];> >}> >}> >cout <<>'Minimum element is: '> << min <<>'
'>;> }> // Code submitted by Susobhan Akhuli> |
>
>Uitvoer
Minimum element is: 10>
Tijdcomplexiteit: O(n) waarbij n de grootte van de array is
Ruimtecomplexiteit: O(n) waarbij n de grootte van de array is.
C++ Overbelasting (functie)
Als we twee of meer leden maken met dezelfde naam, maar verschillend in aantal of type parameters, staat dit bekend als C++-overbelasting. In C++ kunnen we het volgende overbelasten:
- methoden,
- constructeurs en
- geïndexeerde eigenschappen
Soorten overbelasting in C++ zijn:
- Overbelasting van functies
- Overbelasting van de machinist
C++-functie overbelasting
Functieoverbelasting wordt gedefinieerd als het proces waarbij twee of meer functies dezelfde naam hebben, maar verschillende parameters. Bij overbelasting van functies wordt de functie opnieuw gedefinieerd door verschillende typen of een ander aantal argumenten te gebruiken. Alleen door deze verschillen kan een compiler onderscheid maken tussen de functies.
Het voordeel van functieoverbelasting is dat het de leesbaarheid van het programma vergroot, omdat u geen verschillende namen voor dezelfde actie hoeft te gebruiken.
Voorbeeld: het aantal argumenten van de add()-methode wijzigen
C++
// program of function overloading when number of arguments> // vary> #include> using> namespace> std;> class> Cal {> public>:> >static> int> add(>int> a,>int> b) {>return> a + b; }> >static> int> add(>int> a,>int> b,>int> c)> >{> >return> a + b + c;> >}> };> int> main(>void>)> {> >Cal C;>// class object declaration.> >cout << C.add(10, 20) << endl;> >cout << C.add(12, 20, 23);> >return> 0;> }> // Code Submitted By Susobhan Akhuli> |
>
>Uitvoer
30 55>
Tijdcomplexiteit: O(1)
Ruimtecomplexiteit: O(1)
Voorbeeld: wanneer het type argumenten varieert.
C++
// Program of function overloading with different types of> // arguments.> #include> using> namespace> std;> int> mul(>int>,>int>);> float> mul(>float>,>int>);> int> mul(>int> a,>int> b) {>return> a * b; }> float> mul(>double> x,>int> y) {>return> x * y; }> int> main()> {> >int> r1 = mul(6, 7);> >float> r2 = mul(0.2, 3);> >cout <<>'r1 is : '> << r1 << endl;> >cout <<>'r2 is : '> << r2 << endl;> >return> 0;> }> // Code Submitted By Susobhan Akhuli> |
>
>Uitvoer
r1 is : 42 r2 is : 0.6>
Tijdcomplexiteit: O(1)
Ruimtecomplexiteit: O(1)
Functie-overbelasting en dubbelzinnigheid
Wanneer de compiler niet kan beslissen welke functie moet worden aangeroepen uit de overbelaste functie, staat deze situatie bekend als functie overbelasting van dubbelzinnigheid.
Wanneer de compiler de dubbelzinnigheidsfout vertoont, voert de compiler het programma niet uit.
Oorzaken van dubbelzinnigheid:
- Type conversie.
- Functie met standaardargumenten.
- Functie met pass-by-referentie.
Typeconversie: -
C++
#include> using> namespace> std;> void> fun(>int>);> void> fun(>float>);> void> fun(>int> i) { cout <<>'Value of i is : '> << i << endl; }> void> fun(>float> j)> {> >cout <<>'Value of j is : '> << j << endl;> }> int> main()> {> >fun(12);> >fun(1.2);> >return> 0;> }> // Code Submitted By Susobhan Akhuli> |
>
>
Het bovenstaande voorbeeld toont een fout roep van overbelast ‘fun(double)’ is dubbelzinnig . De fun(10) zal de eerste functie aanroepen. De fun(1.2) roept de tweede functie aan volgens onze voorspelling. Maar dit verwijst niet naar een functie zoals in C++, alle drijvende-kommaconstanten worden behandeld als dubbel en niet als zwevend. Als we float vervangen door double, werkt het programma. Daarom is dit een typeconversie van float naar double.
Functie met standaardargumenten: -
C++
#include> using> namespace> std;> void> fun(>int>);> void> fun(>int>,>int>);> void> fun(>int> i) { cout <<>'Value of i is : '> << i << endl; }> void> fun(>int> a,>int> b = 9)> {> >cout <<>'Value of a is : '> << a << endl;> >cout <<>'Value of b is : '> << b << endl;> }> int> main()> {> >fun(12);> >return> 0;> }> // Code Submitted By Susobhan Akhuli> |
>
>
Het bovenstaande voorbeeld toont een fout roep van overbelast ‘fun(int)’ is dubbelzinnig . Fun(int a, int b=9) kan op twee manieren worden aangeroepen: ten eerste door de functie aan te roepen met één argument, namelijk fun(12), en een andere manier is door de functie aan te roepen met twee argumenten, namelijk fun(4). ,5). De functie fun(int i) wordt aangeroepen met één argument. Daarom kon de compiler niet kiezen tussen fun(int i) en fun(int a,int b=9).
Functie met Pass By-referentie: -
C++
#include> using> namespace> std;> void> fun(>int>);> void> fun(>int>&);> int> main()> {> >int> a = 10;> >fun(a);>// error, which fun()?> >return> 0;> }> void> fun(>int> x) { cout <<>'Value of x is : '> << x << endl; }> void> fun(>int>& b)> {> >cout <<>'Value of b is : '> << b << endl;> }> // Code Submitted By Susobhan Akhuli> |
tostring in Java
>
>
Het bovenstaande voorbeeld toont een fout roep van overbelast ‘fun(int&)’ is dubbelzinnig . De eerste functie heeft één geheel getal-argument nodig en de tweede functie heeft een referentieparameter als argument. In dit geval weet de compiler niet welke functie de gebruiker nodig heeft, aangezien er geen syntactisch verschil is tussen fun(int) en fun(int &).
Vriend Functie
- Een vriendfunctie is een speciale functie in C++ die, ondanks dat hij geen lid is van een klasse, het voorrecht heeft toegang te krijgen tot privé- en beschermde gegevens van een klasse.
- Een vriendfunctie is een niet-lidfunctie of een gewone functie van een klasse, die wordt gedeclareerd door het trefwoord vriend binnen de klasse te gebruiken. Door een functie als vriend te declareren, worden alle toegangsrechten aan de functie gegeven.
- Het trefwoord vriend wordt alleen in de functiedeclaratie geplaatst, maar niet in de functiedefinitie.
- Wanneer de vriendfunctie wordt aangeroepen, wordt noch de naam van het object, noch de puntoperator gebruikt. Het kan het object echter wel accepteren als een argument waarvan het de waarde wil benaderen.
- Een vriendfunctie kan in elke sectie van de klasse worden gedeclareerd, d.w.z. openbaar, privé of beschermd.
Verklaring van vriendfunctie in C++
Syntaxis:
class { friend (argument/s); };> Voorbeeld_1: Vind de grootste van twee getallen met behulp van de vriendfunctie
C++
#include> using> namespace> std;> class> Largest {> >int> a, b, m;> public>:> >void> set_data();> >friend> void> find_max(Largest);> };> void> Largest::set_data()> {> >cout <<>'Enter the first number : '>;> >cin>> een;> >cout <<>'
Enter the second number : '>;> >cin>> b;> }> void> find_max(Largest t)> {> >if> (t.a>t.b)> >t.m = t.a;> >else> >t.m = t.b;> >cout <<>'
Largest number is '> << t.m;> }> int> main()> {> >Largest l;> >l.set_data();> >find_max(l);> >return> 0;> }> |
>
>
Uitvoer
Enter the first number : 789 Enter the second number : 982 Largest number is 982>