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.

Definiera funktionsprototypen (utanför int main())

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

Anropa funktionen inuti int main()

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

  greeting();
}

Skriv funktionens brödtext efter

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.

Definiera funktionen (utanför int main())

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

Anropa funktionen inuti 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#

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).

Definiera funktionen (utanför int main())

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

Anropa funktionen med en parameter inuti 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");
}

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.

Definiera funktionen (utanför int main())

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

Anropa funktionen med en parameter inuti 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));
}

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.

Definiera funktionen (utanför int main())

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

Anropa funktionen med en parameter inuti 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
}

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

Definiera funktionen (utanför int main())

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

Anropa funktionen med en parameter inuti 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
}

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.

Definiera callback-funktionen (utanför int main())

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

Registrera återuppringningen inuti 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#

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.

Definiera funktionen (utanför 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();
    }
}

Anropa funktionen inuti 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);
}
On this page