Funkce#

Zavedení#

Funkce jsou základní součástí programování v C++, balí úryvky kódu do opakovaně použitelných a efektivních částí kódu určených k provádění konkrétního úkolu. Funkce lze v programu volat vícekrát, což usnadňuje organizaci kódu a pomáhá vyhnout se opakování kódu. Funkce také usnadňují ladění kódu.

Tato stránka se zabývá základy používání funkcí v jazyce C++, včetně:

Struktura a syntaxe funkcí#

V C++ musí být funkce deklarovány s jejich návratovým typem, názvem a parametry. Základní syntaxe je:

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

Funkční části

Popis

return_type

Datový typ, který funkce vrací. Mezi běžné možnosti patří:

  • void — Nevrací nic
  • int — Vrací celočíselnou hodnotu
  • double — Vrací číslo s plovoucí desetinnou čárkou
  • bool — Vrací true nebo false
  • char — Vrací jeden znak
  • const char* — Vrací textový řetězec
  • uživatelem definované typy — Vrací struct nebo objekt třídy

function_name

Název funkce.

parameters

Volitelné. Seznam typovaných parametrů oddělených čárkami, zapsaný jako type name, kde type určuje datový typ parametru a name je identifikátor použitý pro přístup k této hodnotě uvnitř funkce. Parametry přijímají vstupní hodnoty při volání funkce.

result

Volitelné. Hodnota vrácená funkcí. Pokud return_type funkce není void, musí být tato hodnota zadána a její typ musí přesně odpovídat zadanému return_type.

Poznámka: Funkce musí být vždy deklarována před svým voláním*, nebo musíte poskytnout prototyp funkce.

Funkční prototypy#

V C++ se kód čte odshora dolů. To znamená, že funkce musí být kompilátoru známa, než ji lze zavolat.

Prototyp funkce vám umožňuje použít funkci před napsáním jejího plného kódu. To vám umožňuje ponechat main() blízko začátku programu, zatímco definice funkcí umístíte později, kde se snáze uspořádají a čtou.

Bez prototypu byste museli definovat každou funkci nad main(), což může ztěžovat sledování projektů s jejich růstem.

Definujte prototyp funkce (mimo int main())

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

Zavolejte funkci uvnitř int main()

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

  greeting();
}

Tělo funkce napište za

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

Definování a volání funkcí#

Functions with No Parameters#

Pokud funkce nevyžaduje vstup, můžete ji definovat bez parametrů. Pokud funkce nevrací hodnotu, použijte jako návratový typ void.

Definujte funkci (mimo int main())

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

Zavolejte funkci uvnitř 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#

Funkcem můžete také přidat parametry, které vám umožní předat informace, které má funkce použít.

Poznámka: Text lze předávat pomocí řetězců ve stylu C (const char*) nebo řetězců C++ (std::string).

Definujte funkci (mimo int main())

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

Volejte funkci s parametrem uvnitř 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");
}

Návratové hodnoty#

Funkce mohou odesílat data zpět volajícímu pomocí klíčového slova return To vám umožňuje zachytit a použít výstup ve vašem projektu.

Definujte funkci (mimo int main())

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

Volejte funkci s parametrem uvnitř 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));
}

Předávání odkazem#

Ve výchozím nastavení C++ předává parametry funkcí podle hodnoty, což znamená, že funkce obdrží kopii původní proměnné. Změny provedené uvnitř funkce neovlivní původní hodnotu.

Definujte funkci (mimo int main())

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

Volejte funkci s parametrem uvnitř 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
}

Aby funkce mohla modifikovat původní proměnnou variable, lze parametry předávat odkazem pomocí symbolů &.

Definujte funkci (mimo int main())

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

Volejte funkci s parametrem uvnitř 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
}

Předávání odkazem umožňuje funkcím aktualizovat proměnné variables definované mimo funkci bez vrácení hodnoty.

Funkce zpětného volání#

Funkce zpětného volání je funkce, která je předávána jiné funkci a volána automaticky, když dojde k určité události.

Zpětná volání se běžně používají pro události, jako jsou stisknutí tlačítek nebo aktualizace senzorů.

Místo vlastního volání funkce ji projekt zavolá za vás, když k události dojde.

Definujte callback funkci (mimo int main())

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

Zaregistrujte zpětné volání uvnitř 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#

Každá callback funkce musí mít specifickou signaturu, která definuje:

  • Návratový typ

  • Počet parametrů

  • Typy parametrů

Požadovaný podpis je určen rozhraním API. Funkce zpětného volání se musí tomuto podpisu přesně shodovat.

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

Názvy parametrů jsou popisné a mohou se lišit, ale návratový typ, pořadí parametrů a typy parametrů se musí přesně shodovat.

Funkce s výchozími argumenty#

Funkce mohou definovat výchozí hodnoty pro jeden nebo více parametrů. Výchozí argument se použije, když pro daný parametr není při volání funkce zadána žádná hodnota.

Pravidla pro výchozí argumenty:

  • Výchozí argumenty musí být posledními parametry v definici funkce.

  • Jakmile má parametr výchozí hodnotu, musí mít všechny parametry za ním také výchozí hodnoty.

  • Pokud funkce ve svém prototype specifikuje výchozí argumenty, nesmí být tyto výchozí hodnoty znovu specifikovány v definici funkce.

Definujte funkci (mimo 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();
    }
}

Zavolejte funkci uvnitř int main()

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

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

  Brain.Screen.newLine();

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