Functies#

Invoering #

Functies vormen een fundamenteel onderdeel van C+±programmering. Ze bundelen codefragmenten in herbruikbare, efficiënte codeblokken die ontworpen zijn om een specifieke taak uit te voeren. Functies kunnen meerdere keren binnen een programma worden aangeroepen, wat de code-organisatie vereenvoudigt en helpt om herhaalde code te voorkomen. Functies maken de code bovendien gemakkelijker te debuggen.

Deze pagina behandelt de basisprincipes van het gebruik van functies in C++, waaronder:

Functiestructuur en syntaxis — Hoe functies in C++ worden geschreven, inclusief retourtypen, namen en parameters.
Functieprototypes — Wat prototypefuncties zijn en waarom ze worden gebruikt.
Functies definiëren en aanroepen — Hoe u functies kunt maken en vanuit uw programma kunt aanroepen.
Retourwaarden — Hoe functies gegevens terug kunnen sturen naar de aanroeper.
Passing by Reference — Hoe functies variabelen buiten hun eigen bereik kunnen wijzigen.
Callbackfuncties — Hoe functies aan andere functies kunnen worden doorgegeven en automatisch kunnen worden aangeroepen als reactie op gebeurtenissen.
Functies met standaardargumenten — Hoe parameters standaardwaarden kunnen krijgen wanneer er geen argument wordt meegegeven.

Functiestructuur en syntaxis #

In C++ moeten functies worden gedeclareerd met hun retourtype, naam en parameters. De basissyntaxis is:

return_type function_name(parameters) {
  // Code to execute when the function is called
  return result;  // Optional, used to return a value
}

Functionele onderdelen	Beschrijving
`return_type`	Het gegevenstype dat de functie retourneert, enkele veelvoorkomende opties zijn: `void` — Retourneert niets `int` — Retourneert een integerwaarde `double` — Retourneert een drijvende-komma getal `bool` — Retourneert `true` of `false` `char` — Retourneert een enkel teken `const char*` — Retourneert een tekstreeks door de gebruiker gedefinieerde typen — Retourneert een `struct` of klasseobject
`function_name`	De naam van de functie.
`parameters`	Optioneel. Een door komma’s gescheiden lijst van getypte parameters, geschreven als `type name`, waarbij `type` het gegevenstype van de parameter aangeeft en `name` de identifier is die wordt gebruikt om die waarde binnen de functie te benaderen. Parameters ontvangen invoerwaarden wanneer de functie wordt aangeroepen.
`result`	Optional. The value returned by the function. If the function’s `return_type` is not `void`, this value must be provided and its type must exactly match the specified `return_type`.

Opmerking: Een functie moet altijd worden gedeclareerd voordat deze wordt aangeroepen, of u moet een functieprototype opgeven.

Functieprototypes #

In C++ wordt code van boven naar beneden gelezen. Dit betekent dat een functie bekend moet zijn bij de compiler voordat deze kan worden aangeroepen.

Met een functieprototype kun je een functie gebruiken voordat je de volledige code schrijft. Hierdoor kun je main() bovenaan je programma plaatsen, terwijl je de functiedefinities later in het programma zet, waar ze gemakkelijker te organiseren en te lezen zijn.

Zonder een prototype zou je elke functie main()moeten definiëren, wat het beheer van projecten kan bemoeilijken naarmate ze groeien.

Definieer het functieprototype (buiten int main())

// The function's prototype
void greeting();

Roep de functie aan binnen int main()

int main() {
  /* vexcodeInit() is only required when using VEXcode.
  Remove vexcodeInit() if compiling in VS Code. */
  vexcodeInit();

  greeting();
}

Schrijf de functiebody na

void greeting() {
  Brain.Screen.print("Hello!");
}

Functies definiëren en aanroepen #

Functions with No Parameters #

Als een functie geen invoer vereist, kunt u deze zonder parameters definiëren. Gebruik void als retourtype als de functie geen waarde retourneert.

Definieer de functie (buiten int main())

// Define a function to display a message
void greeting() {
    Brain.Screen.print("Hello!");
}

Roep de functie aan binnen int main()

int main() {
  /* vexcodeInit() is only required when using VEXcode.
  Remove vexcodeInit() if compiling in VS Code. */
  vexcodeInit();

  // Call the function to display the message
  greeting();
}

Functions with Parameters #

Je kunt ook parameters aan functies toevoegen, waarmee je informatie kunt doorgeven die de functie kan gebruiken.

Opmerking: Tekst kan worden doorgegeven met behulp van C-stijl strings (const char*) of C++ strings (std::string).

Definieer de functie (buiten int main())

// Define a function with a parameter
void namedGreeting(const char* name) {
    Brain.Screen.print("Hello, %s!", name);
}

Roep de functie aan met een parameter erin int main()

int main() {
  /* vexcodeInit() is only required when using VEXcode.
  Remove vexcodeInit() if compiling in VS Code. */
  vexcodeInit();

  // Call the function to display the message
  namedGreeting("Stranger");
}

Retourwaarden #

Functies kunnen gegevens terugsturen naar de aanroeper met behulp van het trefwoord return . Hierdoor kunt u de uitvoer vastleggen en gebruiken in uw project.

Definieer de functie (buiten int main())

// Define a function that multiplies numbers by 2
int timesTwo(int number) {
    return number * 2;
}

Roep de functie aan met een parameter erin int main()

int main() {
  /* vexcodeInit() is only required when using VEXcode.
  Remove vexcodeInit() if compiling in VS Code. */
  vexcodeInit();

  // Display the return value
  Brain.Screen.print("%d", timesTwo(2));
}

Passeren via referentie #

Standaard geeft C++ functieparameters per waarde door, wat betekent dat de functie een kopie van de oorspronkelijke variabele ontvangt. Wijzigingen die binnen de functie worden aangebracht, hebben geen invloed op de oorspronkelijke waarde.

Definieer de functie (buiten int main())

// Add 1 to the number
void addOne(int number) {
  number++;
}

Roep de functie aan met een parameter erin int main()

int main() {
  /* vexcodeInit() is only required when using VEXcode.
  Remove vexcodeInit() if compiling in VS Code. */
  vexcodeInit();

  int value = 5;
  addOne(value);
  // "value" will still be 5
}

Om een functie in staat te stellen de oorspronkelijke variabele te wijzigen, kunnen parameters via referentie worden doorgegeven met behulp van de symbolen &.

Definieer de functie (buiten int main())

// Add 1 to the number
void addOne(int& number) {
  number++;
}

Roep de functie aan met een parameter erin int main()

int main() {
  /* vexcodeInit() is only required when using VEXcode.
  Remove vexcodeInit() if compiling in VS Code. */
  vexcodeInit();

  int value = 5;
  addOne(value);
  // "value" will now be 6
}

Passing by reference maakt het mogelijk dat functies variabelen die buiten de functie zijn gedefinieerd, bijwerken zonder een waarde terug te geven.

Callbackfuncties #

Een callbackfunctie is een functie die aan een andere functie wordt doorgegeven en automatisch wordt aangeroepen wanneer een specifieke gebeurtenis plaatsvindt.

Callbacks worden vaak gebruikt voor gebeurtenissen zoals het indrukken van knoppen of het bijwerken van sensoren.

In plaats van de functie zelf aan te roepen, roept het project deze voor je aan wanneer de gebeurtenis plaatsvindt.

Definieer de callbackfunctie (buiten int main())

// Create a callback function
void onPressed() {
  Brain.Screen.print("Screen pressed!");
}

Registreer de callback binnen int main()

int main() {
  /* vexcodeInit() is only required when using VEXcode.
  Remove vexcodeInit() if compiling in VS Code. */
  vexcodeInit();

  // Call onPressed whenever the screen is pressed
  Brain.Screen.pressed(onPressed);
}

Callback Signatures #

Elke callbackfunctie moet voldoen aan een specifieke signatuur, die het volgende definieert:

Het retourtype
Het aantal parameters
De parametertypen

De vereiste handtekening wordt bepaald door de API. De callbackfunctie moet exact overeenkomen met deze handtekening.

// This callback function cannot include any parameters
void callback(void);

// This callback function includes four parameters
void callback(axisType axis, double x, double y, double z);

Parameternamen zijn beschrijvend en kunnen variëren, maar het retourtype, de parametervolgorde en de parametertypen moeten exact overeenkomen.

Functies met standaardargumenten #

Functies kunnen standaardwaarden definiëren voor een of meer parameters. Een standaardargument wordt gebruikt wanneer er geen waarde voor die parameter wordt opgegeven bij het aanroepen van de functie.

Regels voor standaardargumenten:

Standaardargumenten moeten de laatste parameters in de functiedefinitie zijn.
Zodra een parameter een standaardwaarde heeft, moeten alle parameters die erna komen ook een standaardwaarde hebben.
Als een functie standaardargumenten in zijn prototype specificeert, mogen die standaardwaarden niet opnieuw in de functiedefinitie worden gespecificeerd.

Definieer de functie (buiten int main())

// Required parameter first, default parameter last
void greeting(const char* name, int repeatCount = 1) {

    for (int i = 0; i < repeatCount; i++) {
        Brain.Screen.print("Hello, %s!", name);
        Brain.Screen.newLine();
    }
}

Roep de functie aan binnen int main()

int main() {
  /* vexcodeInit() is only required when using VEXcode.
  Remove vexcodeInit() if compiling in VS Code. */
  vexcodeInit();

  // Say what name to greet (EXP) and
  // use default value for repeatCount (1)
  greeting("EXP");

  Brain.Screen.newLine();

  // Overrides the default value to 3
  greeting("EXP", 3);
}

// Required parameter first, default parameter last
void greeting(const char* name, int repeatCount = 1) {

    for (int i = 0; i < repeatCount; i++) {
        Brain.Screen.print("Hello, %s!", name);
        Brain.Screen.newLine();
    }
}

int main() {
    vexcodeInit();

    // Say what name to greet (EXP) and
    // use default value for repeatCount (1)
    greeting("EXP");

    Brain.Screen.newLine();

    // Overrides the default value to 3
    greeting("EXP", 3);
}