Funktioner#

Introduktion#

Funktioner är en grundläggande komponent i C+±programmering och paketerar kodavsnitt till återanvändbara, effektiva kodavsnitt som är utformade för att utföra en specifik uppgift. Funktioner kan anropas flera gånger i ett program, vilket gör kodorganisationen enklare och hjälper till att undvika upprepad kod. Funktioner gör det också lättare att felsöka kod.

Den här sidan behandlar grunderna i att använda funktioner i C++, inklusive:

Funktionsstruktur och syntax#

I C++ måste funktioner deklareras med sin returtyp, namn och parametrar. Grundsyntaxen är:

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

Funktionsdelar

Beskrivning

return_type

Datatypen som funktionen returnerar, några vanliga alternativ är:

  • void — Returnerar ingenting
  • int — Returnerar ett heltal
  • double — Returnerar ett flyttal
  • bool — Returnerar true eller false
  • char — Returnerar ett enskilt tecken
  • const char* — Returnerar en textsträng
  • användardefinierade typer — Returnerar ett struct eller klassobjekt

function_name

Funktionens namn.

parameters

Valfritt. En kommaseparerad lista med typade parametrar skriven som type name, där type anger parameterns datatyp och name är identifieraren som används för att komma åt det värdet inuti funktionen. Parametrar tar emot indatavärden när funktionen anropas.

result

Valfritt. Värdet som returneras av funktionen. Om funktionens return_type inte är voidmåste detta värde anges och dess typ måste exakt matcha den angivna return_type.

Obs: En funktion måste alltid deklareras innan den anropas, eller så måste du tillhandahålla en funktionsprototyp.

Funktionsprototyper#

I C++ läses kod uppifrån och ner. Det betyder att en funktion måste vara känd för kompilatorn innan den kan anropas.

En funktionsprototyp låter dig använda ​​en funktion innan du skriver hela dess kod. Detta gör att du kan behålla main() nära toppen av ditt program medan du placerar funktionsdefinitioner senare, där de är lättare att organisera och läsa.

Utan en prototyp skulle du behöva definiera varje funktion ovanför main(), vilket kan göra projekt svårare att följa allt eftersom de växer.

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

int main() {
  greeting();
}

// Write the function's body after
void greeting() {
  Brain.Screen.print("Hello!");
}

Definiera och anropa funktioner#

Functions with No Parameters#

Om en funktion inte kräver inmatning kan du definiera den utan parametrar. Använd void som returtyp om funktionen inte returnerar ett värde.

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

int main() {
    // Initializing Robot Configuration. DO NOT REMOVE!
    vexcodeInit();
    // Call the function to display the message
    greeting();
}

Functions with Parameters#

Du kan också lägga till parametrar till funktioner, vilket låter dig skicka in information som funktionen kan använda.

Obs! Text kan skickas med hjälp av C-strängar (const char*) eller C+±strängar (std::string).

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

int main() {
    // Initializing Robot Configuration. DO NOT REMOVE!
    vexcodeInit();
    namedGreeting("Stranger");
}

Returvärden#

Funktioner kan skicka data tillbaka till anroparen med hjälp av nyckelordet return Detta gör att du kan samla in och använda utdata i ditt projekt.

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

int main() {
    // Initializing Robot Configuration. DO NOT REMOVE!
    vexcodeInit();
    // Display the return value
    Brain.Screen.print("%d", timesTwo(2));
}

Passing By Reference#

Som standard skickar C++ funktionsparametrar efter värde, vilket innebär att funktionen tar emot en kopia av originalet variabel. Ändringar som görs inuti funktionen påverkar inte det ursprungliga värdet.

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

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

För att tillåta en funktion att modifiera den ursprungliga variabeln kan parametrar skickas via referens med hjälp av symbolen &.

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

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

Genom att skicka via referens kan funktioner uppdatera variabler som definierats utanför funktionen utan att returnera ett värde.

Återuppringningsfunktioner#

En callback-funktion är en funktion som skickas till en annan funktion och anropas automatiskt när en specifik händelse inträffar.

Återanrop används ofta för händelser som knapptryckningar eller sensoruppdateringar.

Istället för att anropa funktionen själv, anropar projektet den åt dig när händelsen inträffar.

void onPressed() {
  Brain.Screen.print("Screen pressed!");
}

// Call onPressed whenever the screen is pressed
int main() {
  vexcodeInit();
  Brain.Screen.pressed(onPressed);
}

Callback Signatures#

Varje callback-funktion måste följa en specifik signatur, som definierar:

  • Returtypen

  • Antalet parametrar

  • Parametertyperna

Den obligatoriska signaturen bestäms av API:et. Återanropsfunktionen måste matcha denna signatur exakt.

// 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);

Parameternamn är beskrivande och kan variera, men returtypen, parameterordningen och parametertyperna måste matcha exakt.

Funktioner med standardargument#

Funktioner kan definiera standardvärden för en eller flera parametrar. Ett standardargument används när inget värde anges för den parametern när funktionen anropas.

Regler för standardargument:

  • Standardargument måste vara de sista parametrarna i funktionens definition.

  • När en parameter har ett standardvärde måste alla parametrar efter den också ha standardvärden.

  • Om en funktion anger standardargument i sin prototype, får dessa standardvärden inte anges igen i funktionsdefinitionen.

// 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 (V5) and
    // use default value for repeatCount (1)
    greeting("V5");

    Brain.Screen.newLine();

    // Overrides the default value to 3
    greeting("V5", 3);
}
On this page