Declaradores abstratos C++
Um declarador abstrato é um declarador em que o identificador é omitido. (Para obter informações relacionadas, consulte Nomes de tipo e Declaradores) quando os declaradores não abstratos são usados na declaração de objetos ou das funções, eliminando o identificador e deixando somente as informações de tipo. Portanto, os declaradores abstratos têm o efeito de modificar um tipo de base como char para especificar um tipo mais complexo como o ponteiro para char ou matriz de char. Portanto, eles são sempre usados junto a um nome de tipo de base e usados apenas quando um tipo de ponteiro, matriz ou referência é chamado (incluindo um ponteiro para a função que retorna esse tipo de base). Os declaradores abstratos correspondentes aos elementos a seguir são discutidos nesta seção:
Um declarador abstrato é um declarador que não declara um nome — o identificador é deixado de fora. Por exemplo,
char *
especifica o ponteiro de tipo para o tipo char. O nome do tipo consiste do nome do tipo de base char além do declarados abstrato *.
Da mesma forma, o declarador abstrato para uma referência é & o operador, e um tipo de matriz é especificado usando colchetes. Qualquer tipo pode ser especificado somente aplicando a sintaxe para o declarador e removendo o identificador.
char & // reference to char
char[5] // array of char
O seguinte é um uso mais complicado de um declarador abstrato que declara o ponteiro de tipo para uma função que usa dois argumentos, ambos do tipo char * e retorna o tipo char *:
char * (*)( char *, char * )
Em combinação com o especificador do tipo de base, os declaradores abstratos declaram completamente um tipo. Os nomes de tipo construídos de declaradores abstratos podem ser usados sempre que um tipo for chamado:
// Get the size of array of 10 pointers to type char.
size_t nSize = sizeof( char *[10] );
// cast fptr to pointer to function that takes two arguments, both of type
// pointer to char
i = (char * (*)(char*, char*)) fptr;
O especificador typedef pode ser usado para evitar a repetição da sintaxe frágil de declaradores abstratos.