Přehled deklarátorů

Deklarátory jsou ty součásti deklarace, které určují názvy objektů a funkcí.Určují také, zda je pojmenovaný objekt objektem, ukazatelem, referencí nebo polem.Ačkoli deklarátory neurčují základní typ, upravují informace o typu v základním typu a určují tak odvozené typy jako ukazatele, reference a pole.Deklarátor použitý ve funkci spolupracuje se specifikátorem typu na plném určení návratového typu funkce jako objekt, ukazatel nebo reference.(Specifikátory diskutované v tématu Deklarace poskytují informace o vlastnostech jako typ nebo třída úložiště.Modifikátory diskutované v tomto oddílu a v tématu Modifikátory specifické pro společnost Microsoft upravují deklarátory.) Následující obrázek ukazuje kompletní deklaraci funkce MyFunction a označuje komponenty deklarace.

Specifikátory, modifikátory a deklarátory

Specifické pro Microsoft

Většinu klíčových slov rozšířených společností Microsoft lze použít jako modifikátory a vytvořit tak odvozené typy. Nejsou to specifikátory ani deklarátory.(Informace naleznete v tématu Modifikátory specifické pro společnost Microsoft.)

END Specifické pro Microsoft

Deklarátory se vyskytují v syntaxi deklarace za nepovinným seznamem specifikátorů.O těchto specifikátorech pojednává téma Deklarace. Deklarace může obsahovat více než jeden deklarátor, ale každý deklarátor deklaruje pouze jeden název.

Následující vzorová deklarace ukazuje, jak kombinace specifikátorů a deklarátorů utváří úplnou deklaraci:

const char *pch, ch;

V předchozí deklaraci tvoří klíčová slova const a char seznam specifikátorů.Jsou uvedeny dva deklarátory: *pch a ch.Deklarace deklarující několik entit sestává ze specifikátoru typu následovaného čárkou odděleným seznamem deklarátorů ukončeným středníkem.

Deklarátory pro jednoduché objekty

Deklarátor jednoduchého objektu, například typu int nebo double, je jednoduše jeho název, volitelně se závorkami.

int i; // declarator is i

int (i); // declarator is (i)

Deklarátory pro ukazatele, reference a pole

Operátory ukazatelů vložené před název zajistí, že objekt bude ukazatel nebo reference.* Operátor deklaruje název jako ukazatel; & operátor ji deklaruje jako odkaz.

int *i; // declarator is *i
int **i; // declarator is **i;
int &i = x; // declaratory is &i

Připojením klíčového slova const nebo volatile získá ukazatel tyto speciální vlastnosti.Použití těchto specifikátorů v deklarátoru (na rozdíl od specifikátoru typu) upravuje vlastnosti ukazatele, nikoli objektu, na který ukazatel ukazuje:

char *const cpc; // const pointer to char 
const char *pcc; // pointer to const char 
const char *const cpcc; // const pointer to const char

Další informace lze nalézt v tématu Ukazatele const a volatile.

Ukazatel na člen třídy nebo struktury je deklarován s příslušným zanořeným specifikátorem názvu:

int X::* pIntMember; 
int ::X::* pIntMember; // the initial :: specifies X is in global scope
char Outer::Inner::* pIntMember; // pointer to char in a nested class

Závorky uzavírající nepovinný konstantní výraz za názvem přetváří objekt na pole.Následné závorky deklarují další rozměry pole.

int i[5]; // array with five elements of type int numbered from 0 to 4
int i[]; // array of unknown size
char *s[4]; // array of pointers to char
int i[2][2]; // two dimensional array

Deklarace pro funkce

Pro deklaraci funkce se používají závorky obsahující seznam argumentů za názvem.Následující kód deklaruje funkci návratového typu int a třemi argumenty typu int.

int f(int a, int b, int c);

Informace o seznamech argumentů naleznete v tématu Deklarace funkcí.

Ukazatele a reference na funkce jsou deklarovány přidáním operátoru ukazatele nebo reference před název funkce tak, jak je uvedeno níže.Obvykle nepovinné závorky jsou vyžadovány pro rozlišení ukazatele na funkci od funkce vracející ukazatel:

int (*pf)(int); // pointer to function returning int
int *f(int i); // function returning pointer to int
int (&pf)(int); // reference to function 

Ukazatele na členské funkce jsou odlišeny vnořenými specifikátory názvů:

int (X::* pmf)(); // pointer to member function of X returning int
int* (X::* pmf)(); // pointer to member function returning pointer to int

Další informace naleznete v tématu Ukazatele na členy.

Funkce a objekty v jedné deklaraci

Funkce a objekty lze deklarovat v jedné deklaraci takto:

int i, *j, f(int k);  // int, pointer to int, function returning int

Syntaxe může být v některých případech matoucí.Následující deklarace

int* i, f(int k);  // pointer to int, function returning int (not int*)

může vypadat jako deklarace ukazatele int a funkce vracející typ int*, ale není tomu tak.To proto, že operátor * je součástí deklarátoru proměnné i, nikoli součástí deklarátoru funkce f.

Zjednodušení syntaxe deklarátoru pomocí direktivy typedef

Lepší technikou je však použití direktivy typedef nebo kombinace závorek a klíčového slova typedef.Vezměte v úvahu deklaraci pole ukazatelů na funkce:

//  Function returning type int that takes one 
//   argument of type char *.
typedef int (*PIFN)( char * );
//  Declare an array of 7 pointers to functions 
//   returning int and taking one argument of type 
//   char *.
PIFN pifnDispatchArray[7];

Ekvivalentní deklaraci lze napsat bez deklarace typedef, je však tak komplikovaná, že riziko chyb převažuje nad všemi výhodami:

int ( *pifnDispatchArray[7] )( char * );

Další informace o direktivě typedef naleznete v tématu Specifikátor typedef.

Ukazatele, reference a pole jednoho základního typu lze v jedné deklaraci kombinovat oddělením čárkami následovně

int a, *b, c[5], **d, &e=a;

Složitější syntaxe deklarátoru

• Deklarátory ukazatelů, referencí, polí a funkcí lze kombinovat, a určovat tak objekty jako pole ukazatelů na funkce, ukazatele na pole apod.

• Následující rekurzivní gramatika plně popisuje syntaxi deklarátoru ukazatele.

• Deklarátor declarator je definován jako:

1. identifier 
2. qualified-name 
3. declarator ( argument-list ) [cv-qualfiers] [exception-spec]
4. declarator [ [ constant-expression ] ] 

5. pointer-operator declarator 
6. ( declarator )

• a operátor pointer-operator jako:

* [cv-qualifiers]
& [cv-qualifiers]
:: nested-name-specifier * [cv-qualfiers]

Protože může deklarátor obsahovat deklarátory, lze pomocí výše zmíněných pravidel vytvořit složitější odvozené typy jako pole ukazatelů či funkce vracející pole ukazatelů na funkce.Chcete-li utvořit každý z kroků konstrukce, začněte s identifikátorem představujícím základní datový typ a použijte výše zmíněné pravidlo syntaxe s předchozím výrazem jako deklarátor declarator.Pořadí použití pravidel syntaxe by mělo být opačné oproti způsobu, jak je výraz vyjádřen v angličtině.Používáte-li pravidlo syntaxe pointer-operator na výraz pole nebo funkce a chcete-li získat ukazatel na pole nebo funkci, použijte závorky tak, jak je uvedeno v posledním řádku tabulky níže.

Následující příklad ukazuje tvorbu „ukazatele na pole 10 ukazatelů na typ int“.

Slovní vyjádření	Deklarátor	Použité pravidlo syntaxe
	i	1
ukazatel(e) na	*i	5
pole o 10	(*i)[10]	4
ukazatelích na	*((*i)[10])	6, a potom 5

Při použití většího počtu modifikátorů ukazatelů, referencí, polí nebo funkcí se deklarátory mohou výrazně komplikovat.Téma Interpretace složitějších deklarátorů popisuje, jak číst složitější syntaxi deklarátorů.Téma lze použít pro jazyky C a C++, ačkoli v jazyce C++ lze tam, kde je operátorem * označen ukazatel, použít pro určení ukazatele na člen třídy kvalifikovaný název, například MyClass::*.

Viz také

Referenční dokumentace

Deklarátory