> For the complete documentation index, see [llms.txt](https://girls.gitbook.io/c++-cursus/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://girls.gitbook.io/c++-cursus/leer-meer-c++/10.-functies-deel-2.md).

# 10. Functies - deel 2

In het hoofdstuk [Functies - deel 1](/c++-cursus/leer-meer-c++/8.-functies-deel-1.md) heb je over parameters geleerd. Bij een functie zijn er 2 soorten parameters:

* Call by value: een kopie van de variabele wordt als parameter doorgegeven. Dit betekent dat als de variabele in de functie van waarde veranderd, de originele variabele nog steeds dezelfde waarde heeft.
* Call by reference: de variabele zelf wordt als parameter doorgegeven. Dit betekent dat als de variabele in de functie van waarde veranderd, de originele variabele ook van waarde is veranderd. Met een & teken voor de parameter geef je aan dat dit een call by reference variabele is.

Voorbeeld van call by value:

```cpp
#include <iostream> 
using namespace std;

void hoogOp (int getal_in_functie){
    getal_in_functie++; //Lokaal in de functie wordt de waarde van getal 1
}

int main(){
  int getal = 0; //De variabele getal wordt gedeclareerd met de waarde 0
  hoogOp(getal);
  cout << "Waarde van getal = " << getal; //De waarde in de main is niet opgehoogd 
                                          //en er zal dus 0 geprint worden
  return 0;              
}
```

Voorbeeld van call by reference:

```cpp
#include <iostream> 
using namespace std;

void hoogOp (int &getal_in_functie){
    getal_in_functie ++; //In dit geval is getal een kopie van getal uit de main 
                         //en dus worden beide nu opgehoogd met 1
}

int main(){
  int getal = 0; //De variabele getal wordt gedeclareerd met de waarde 0
  hoogOp(getal);
  cout << "Waarde van getal = " << getal; //Er wordt nu 1 geprint
  return 0;   
}
```

**Opdracht 10.1**\
Probeer beide voorbeelden uit. Wat is het verschil tussen de 2 voorbeelden?&#x20;

Een vector kun je ook call-by-value en call-by-reference aan een functie doorgeven:

`void func(vector<int> vect) //call-by-value`\
`void func(vector<int> &vect) //call-by-reference`

**Opdracht 10.2**\
Maak de opdracht: [vectors](https://informatica.cuttle.org/?action=question_standalone\&que_id=42\&t=53e71ffb0eeeb3cd).\
Schrijf nette code door gebruik te maken van functies.

### **Built-in functies**

C++ bevat nuttige functies die je kan gebruiken. Bijvoorbeeld:\
\- `min`: geeft de kleinste van 2 getallen\
\- `max`: geeft de grootste van 2 getallen\
\- `swap`: hiermee kun je de waardes van 2 variabelen omwisselen\
\- `sqrt`: berekent de wortel. Deze kot\
\- `pow`: berekent de macht\
\- `ceil`: naar boven afronden\
\- `floor`: naar beneden afronden\
\- `sort`: sorteert de waardes in een array\
\
Voor sommige functies moet je wel een extra library toevoegen aan je code. Bijvoorbeeld:

```cpp
#include <iostream>     
#include <string>    
#include <vector>
#include <algorithm>    
#include <cmath>
```

Op de pagina <https://en.cppreference.com/w/cpp/header> kun je een reference vinden van alle libraries. Als je bijvoorbeeld de library \<cmath> selecteert dan kan je alle built-in functies zien van deze library.

\
**Opdracht 10.3**\
Bepaal de kleinste van 3 getallen met de functie min. Kijk op de reference pagina hoe je de functie min kan gebruiken.

**Opdracht 10.4**\
Schrijf een programma dat de cijfers in onderstaande vector sorteert. Maak gebruik van de functie `sort`.  Kijk op de reference pagina hoe je de functie `sort` kan gebruiken.\
vector cijfers = { 5, 4, 9, 12, 8, 7, 13, 15, 4, 2, 1, 0, 4, 2, 5, 0, 4, 2, 10, 5, 20, 1, 7, 23, 16};

{% hint style="info" %}
Zoals je kan zien zijn er veel verschillende standaard libaries die je kan toevoegen aan je code. Je kunt alle standaard libraries ook in een keer toevoegen met de code:

`#include <bits/stdc++.h>`\
Deze code is tijdens programmeerwedstrijden heel nuttig omdat het je tijd bespaart. Maar het heeft ook zeker nadelen dus buiten programmeerwedstrijden is het beter dit niet te gebruiken.
{% endhint %}

### Samenvatting - nuttige functies voor een vector

```cpp
int main() {
    vector<int> v; 

    /*
        Nuttige functies voor een VECTOR
        1) .assign()
        2) .size()
        3) .push_back()
        4) .front() & .back()
        5) .clear()
        6) reverse()
        7) sort()
        8) find()
        9) .erase()
        10) .lower_bound() & .upper_bound()
    */

    // .assign(grootte, waarde)
    v.assign(5, 1); // v = {1, 1, 1, 1, 1}

    // .size() => grootte van de vector
    cout << v.size() << '\n'; // output: 5

    // .push_back() => waarde toevoegen las laatste element
    v.push_back(4); // v = {1, 1, 1, 1, 1, 4}

    // .front() en .back() => eerste en laatste element
    cout << v.front() << '\n'; // eerste element; output: 1
    cout << v.back() << '\n'; // laatste element; output: 4

    v.clear(); // verwijdert alle elementen in v, dus v = {}

    v = {5, 9, 1, 3, 6, 6, 9, 18}; 

    // reverse => vector omkeren
    reverse(v.begin(), v.end()); // v = {18, 9, 6, 6, 3, 1, 9, 5}

    // sort => sorteer de elementen in OPLOPENDE volgorde
    sort(v.begin(), v.end()); // v = {1, 3, 5, 6, 6, 9, 9, 18}
    // sorteer de elementen in AFLOPENDE volgorde
    sort(v.begin(), v.end(), greater<int>()); // v = {18, 9, 9, 6, 6, 5, 3, 1}

    // find => geeft een iterator die wijst naar het element die je wil vinden
    // als het element er niet is, dan geeft die de .end() iterator
    // als het element meerdere keren in de vector zit, wijst de iterator de eerste aan
    auto it = find(v.begin(), v.end(), 6); // 6 zoeken in v
    if (it == v.end()) {
        cout << "6 zit niet in vector v!" << '\n';
    } else {
        cout << "Element 6 gevonden!" << '\n';
        // index vinden met de iterator:
        cout << "De eerste 6 zit op positie " << it - v.begin() << '\n'; // output: De eerste 6 zit op positie 3
    }

    // .erase() verwijdert de element met een iterator 
    v.erase(it); // de eerste 6 is nu verwijderd; v = {18, 9, 9, 6, 5, 3, 1}
    v.erase(find(v.begin(), v.end(), 9)); // verwijder de eerste 9 in v; v = {18, 9, 6, 5, 3, 1}


    sort(v.begin(), v.end()); // v = {1, 3, 5, 6, 9, 18}
    // voor gebruik van lower_bound en upper_bound upper_bound moest de vector eerst gesorteerd worden!
    it = lower_bound(v.begin(), v.end(), 6); // geeft een iterator die wijst naar het eerste element dat GELIJK IS AAN of GROTER IS DAN 6
    cout << "De eerste element gelijk aan of groter dan 6 is " << *it << '\n'; // output: 6
    it = upper_bound(v.begin(), v.end(), 6); // geeft een iterator die wijs naar het eerste element dat GROTER DAN 6 is
    cout << "De eerste element groter dan 6 is " << *it << '\n'; // output: 9
    
    // als er niks is gevonden, geven de functies de .end() iterator, bijv.
    it = upper_bound(v.begin(), v.end(), 18);
    if (it == v.end()) cout << "Geen getal boven de 18 gevonden!\n"; // output: Geen getal boven de 18 gevonden!
    
    return 0;
}
```