Výrazy přípony

Článek
10/12/2023

Výrazy přípony jsou tvořeny primárními výrazy nebo výrazy, ve kterých příponové operátory následují za primárním výrazem. Příponové operátory jsou uvedeny v následující tabulce.

Operátory přípony

Název operátoru	Zápis operátoru
Operátor dolního indexu	[ ]
Operátor volání funkce	( )
Operátor převodu explicitního typu	type-name( )
Operátor přístupu člena	. nebo ->
Operátor přírůstku přípony	++
Operátor dekrementace přípony	--

Následující syntaxe popisuje možné výrazy přípony:

primary-expression
postfix-expression[expression]postfix-expression(expression-list)simple-type-name(expression-list)postfix-expression.namepostfix-expression->namepostfix-expression++postfix-expression--cast-keyword < typename > (expression )typeid ( typename )

Výše uvedený výraz přípony může být primárním výrazem nebo jiným výrazem přípony. Výrazy přípony se seskupují zleva doprava, takže umožňují následující řetězení výrazů:

func(1)->GetValue()++

Ve výše uvedeném výrazu func je primární výraz, func(1) je výraz přípony funkce, je výraz přípony určující func(1)->GetValue člen třídy, func(1)->GetValue() je další výraz funkce postfix a celý výraz je výraz přípony, který zvýší návratovou hodnotu GetValue. Význam výrazu jako celek je volání funkce func předávající hodnotu 1 jako argument a získání ukazatele na třídu jako návratové hodnoty. Potom zavolejte GetValue() na danou třídu a pak navýšte vrácenou hodnotu.

Výrazy uvedené výše jsou výrazy přiřazení, což znamená, že výsledkem těchto výrazů musí být hodnota r-value.

Tvar výrazu přípony

simple-type-name ( expression-list )

označuje volání konstruktoru. Pokud je simple-type-name základní typ, musí být seznam výrazů jeden výraz a tento výraz označuje přetypování hodnoty výrazu na základní typ. Tento typ výrazu přetypování napodobuje konstruktor. Vzhledem k tomu, že tento tvar umožňuje základním typům a třídám, aby byly konstruovány pomocí stejné syntaxe, je tento tvar obzvláště užitečný při definování tříd šablon.

Klíčové slovo přetypování je jedno z dynamic_cast, static_cast nebo reinterpret_cast. Další informace mohou být nalezeny v dynamic_casta reinterpet_caststatic_cast .

Operátor typeid je považován za výraz přípony. Viz operátor typeid.

Formální a skutečné argumenty

Volání programů předává informace volání funkcím ve skutečných argumentech. Volané funkce přistupuje k informacím pomocí odpovídajících "formálních argumentů".

Při volání funkce jsou provedeny následující úkoly:

Jsou vyhodnoceny všechny skutečné argumenty (poskytnuté volajícím). Neexistuje žádné předpokládané pořadí, ve kterém jsou tyto argumenty vyhodnoceny, ale před vstupem do této funkce jsou vyhodnoceny všechny argumenty a dokončeny všechny vedlejší účinky.
Každý formální argument je inicializován s jeho odpovídajícím skutečným argumentem v seznamu výrazů. (Formální argument je argument, který je deklarován v záhlaví funkce a použit v těle funkce.) Převody se provádějí stejně jako při inicializaci – při převodu skutečného argumentu na správný typ se provádí standardní i uživatelsky definované převody. Provedená inicializace je konceptuálně znázorněna následujícím kódem:
```
void Func( int i ); // Function prototype
...
Func( 7 );          // Execute function call
```
Konceptuální inicializace provedené před voláním jsou:
```
int Temp_i = 7;
Func( Temp_i );
```
Inicializace probíhá, jako kdyby byla použita syntaxe znaménka rovnosti namísto syntaxe se závorkami. Před předáním této hodnoty funkci je vytvořena kopie proměnné i. (Další informace najdete v tématu Inicializátory a převody).

Proto pokud prototyp funkce (deklarace) volá argument typu longa pokud volající program dodává skutečný argument typu int, skutečný argument je povýšen pomocí standardního převodu typu na typ long (viz Standardní převody).

Poskytnutí skutečného argumentu, pro který neexistuje žádný standardní nebo uživatelem definovaný převod na typ formálního argumentu, vygeneruje chybu.

Pro skutečné argumenty typu třídy je formální argument inicializován pomocí volání konstruktoru třídy. (Viz Konstruktory pro další informace o těchto speciálních funkcích členů třídy.)
Je provedeno volání funkce.

Následující fragment programu znázorňuje volání funkce:

// expre_Formal_and_Actual_Arguments.cpp
void func( long param1, double param2 );

int main()
{
    long i = 1;
    double j = 2;

    // Call func with actual arguments i and j.
    func( i, j );
}

// Define func with formal parameters param1 and param2.
void func( long param1, double param2 )
{
}

Při func zavolání z main je formální parametr param1 inicializován s hodnotou i (i je převeden na typ long odpovídající správnému typu pomocí standardního převodu) a formální parametr param2 je inicializován s hodnotou j (j je převeden na typ double pomocí standardního převodu).

Ošetření typů argumentů

Formální argumenty deklarované jako const typy nelze změnit v těle funkce. Funkce mohou změnit libovolný argument, který není typu const. Změna je však místní pro funkci a nemá vliv na hodnotu skutečného argumentu, pokud skutečný argument nebyl odkaz na objekt, který není typu const.

Následující funkce znázorňují některé z těchto konceptů:

// expre_Treatment_of_Argument_Types.cpp
int func1( const int i, int j, char *c ) {
   i = 7;   // C3892 i is const.
   j = i;   // value of j is lost at return
   *c = 'a' + j;   // changes value of c in calling function
   return i;
}

double& func2( double& d, const char *c ) {
   d = 14.387;   // changes value of d in calling function.
   *c = 'a';   // C3892 c is a pointer to a const object.
    return d;
}

Tři tečky a výchozí argumenty

Funkce lze deklarovat tak, aby přijímaly méně argumentů, než je zadáno v definici funkce, pomocí jedné ze dvou metod: tří teček (...) nebo výchozích argumentů.

Tři tečky označují, že argumenty mohou být požadovány, ale že číslo a typy nejsou zadány v deklaraci. To je obvykle špatná programovací praxe jazyka C++, protože porazí jednu z výhod C++: bezpečnost typů. Různé převody se použijí na funkce deklarované se třemi tečkami než u těch funkcí, pro které jsou známy formální a skutečné typy argumentů:

Pokud je skutečný argument typu float, je povýšen na typ double před voláním funkce.
Libovolný signed char nebo unsigned charnebo , signed short výčtový unsigned shorttyp nebo bitové pole je převedeno na signed int celočíselné povýšení nebo unsigned int použití.
Libovolný argument typu třídy je předán hodnotou jako datová struktura; kopie je vytvořena binárním kopírováním místo vyvoláním konstruktoru kopírování třídy (pokud existuje).

Tři tečky, pokud se použijí, musí být v seznamu argumentů deklarovány jako poslední. Další informace o předávání proměnlivého počtu argumentů najdete v diskuzi o va_arg, va_start a va_list v referenčních informacích ke knihovně runtime.

Informace o výchozích argumentech v programování CLR naleznete v tématu Seznamy argumentů proměnných (...) (C++/CLI).

Výchozí argumenty umožňují zadat hodnotu, kterou by argument měl předpokládat, pokud není ve volání funkce zadán žádný. Následující fragment kódu ukazuje, jak fungují výchozí argumenty. Další informace o omezeních zadávání výchozích argumentů naleznete v tématu Výchozí argumenty.

// expre_Ellipsis_and_Default_Arguments.cpp
// compile with: /EHsc
#include <iostream>

// Declare the function print that prints a string,
// then a terminator.
void print( const char *string,
            const char *terminator = "\n" );

int main()
{
    print( "hello," );
    print( "world!" );

    print( "good morning", ", " );
    print( "sunshine." );
}

using namespace std;
// Define print.
void print( const char *string, const char *terminator )
{
    if( string != NULL )
        cout << string;

    if( terminator != NULL )
        cout << terminator;
}

Předchozí program deklaruje funkci, printkterá přebírá dva argumenty. Druhý argument , ukončovací znak, však má výchozí hodnotu, "\n". První maindvě volání, která print umožní výchozímu druhému argumentu zadat nový řádek pro ukončení tištěného řetězce. Třetí volání určuje explicitní hodnotu druhého argumentu. Výstup z programu je

hello,
world!
good morning, sunshine.

Viz také

Typy výrazů

Sdílet prostřednictvím