Expressões e declarações em programação C ++

Para executar um cálculo no programa C ++ você precisa de uma expressão. Uma expressão é uma declaração que tem tanto um valor e um tipo. No programa C ++, uma declaração é a declaração que define uma variável ou é um "tanque de retenção" para algum tipo de valor como um número ou caractere.

Expressões

Expressões tomar uma das seguintes formas:

objname // para uma expressão objectoperator simples // para unário expr2 operador operatorsexpr1 // para operatorsexpr1 binário? expr2: expr3 // para o operatorfuncName ternária ([lista de argumentos]) - // para chamadas de função

expressões literais

Um literal é uma forma de expressão constante. Os vários tipos de literais são definidas na tabela seguinte.

Exemplo	Digitar
1	int
1L	long int
1LL	int long long
1.0	duplo
1.0F	flutuador
'1'	carbonizar
"uma linha"	char * (automaticamente rescindido com um caractere nulo)
L "uma corda"	wchar_t *
u8 "esta é uma string UTF-8 com um caractere UTF-8: u2018"	char8_t *
u "esta é uma string UTF-16 com um personagem UTF-16: u2018"	char16_t *
U "esta é uma string UTF-32 com um personagem UTF-32: U00002018"	char32_t *
verdadeiro falso	bool
0b101	binário (C ++ 2014 standard)

declarações

Declarações usar ambos os tipos intrínsecos e definidos pelo usuário. Os tipos intrínsecos são

[] Char [] Wchar_t [] [] Intfloat [longa] doublebool

Declarações ter uma das seguintes formas:

[] [Const] digite var [= expressão] - // variável [] [const] type array [size] [= {list}] - // array [const] type objeto [(lista de argumentos)] - // objeto [const] type objeto [= {lista de argumentos}] - [const] // alternativa digite * [const] ptr [= expressão ponteiro] - // pointertype refname = object- // referenceType fnName ([lista de argumentos]) - // função

a palavra-chave auto pode ser usado se C ++ pode determinar o tipo de variável si:

auto var = 1L- // o tipo de var é longo int

a palavra-chave decltype extrai o tipo de uma expressão. Este tipo pode, então, ser usado sempre que um nome de tipo é usado. Por exemplo, o exemplo seguinte usa decltype para declarar uma segunda variável com o mesmo tipo como uma variável existente:

decltype (Q1) var2- // o tipo de var2 é o mesmo que var1

A definição de função tem o seguinte formato:

// Função simples [] type fnName (lista de argumentos) {...} // função de membro definida fora da classe [em linha] tipo Class :: func (lista de argumentos) [Const] {...} // construtor / destruidores também pode ser definida fora do classClass :: Class ([lista de argumentos]) {...} Classe Class :: ~ () {...} // construtores / destructor pode ser suprimido ou inadimplentes // em vez de definitionClass: : Classe ([lista de argumentos]) = -Class :: ~ Class () = -

Um operador sobrecarregado parece uma definição de função. A maioria operadores sobrecarregados podem ser escritos ou como membro ou funções simples. Quando escrito como uma função de membro, *esta é o primeiro argumento assumido que o operador:

Minha classe operador + (const MyClass m1, MyClass const m2) - // simpleMyClass MyClass :: operator + (const MyClass m2) - // quadro social

Os usuários também podem definir seus próprios tipos usando o classe ou structpalavras-chave:

 ClassName [: [virtual] [público] ClasseBase] {: // constructorClassName ([lista arg]) lt; [: membro (val), ...] {...} | -> ClassName () [= -] // destructor [virtual] ~ ClassName () lt; {...} | [= -> // Memberstype dados públicos dataMemberName [= initialValue] - // membro público functionstype memberFunctionName ([lista arg]) [{...}] // const membro FunctionType memberFunctionName ([lista arg]) const [{. ..}] // virtual tipo de membro functionsvirtual memberFunctionName ([lista arg]) [{...}] - // virtual pura tipo de membro functionsvirtual memberFunctionName ([lista arg]) = 0 - // função que deve substituir uma base classe FunctionType memberFunctionName ([lista arg]) override - // uma função que não pode ser substituído em uma memberFunctionName subclasstype ([lista arg]) final -} -

Além disso, um construtor com um único argumento pode ser marcado como explícito o que significa que ele não irá ser usado em uma conversão implícita de um tipo para outro. Sinalizando um construtor como padrão significa "usar o padrão de definição de construtor C ++". Sinalizando um construtor como excluir remove definição construtor padrão C ++.

C ++ suporta dois tipos de tipos enumerados. O seguinte tipo de enumeração de idade não cria um novo tipo:

enum ESTADO {DC, // recebe 0ALABAMA, // recebe 1ALASKA, // recebe 2ARKANSAS, // recebe 3 // ... e assim por diante} -int n = ALASKA- // ALASKA é do tipo int

Por padrão uma entrada individual é do tipo int mas isso pode ser mudado no padrão C ++ 2011:

enum ALFABETO: char {A = 'a', // recebe 'A'B, // recebe' B'C, // recebe 'c' // ... e assim por diante} -char c = A- // Um é do tipo char

C ++ 2011 permite que um segundo formato que cria um novo tipo:

// O seguinte enumeração define um estado novo tipo de classe STATEenum {DC, // recebe 0ALABAMA, // recebe 1ALASKA, // recebe 2ARKANSAS, // recebe 3 // ... e assim por diante} -state s = ESTADO :: ALASKA- // agora ESTADO é um novo tipo // o seguinte utiliza um alfabeto classe typeenum subjacente diferente: char {a = 'a', // recebe 'A'B, // recebe' B'C, // recebe ' c '// ... e assim por diante} -Alfabeto c = ALFABETO :: A- // Um ​​é do tipo ALFABETO

declarações de gabarito têm um formato ligeiramente diferente:

// Tipo T é proporcionado pelo programador de usetemplate  Tipo FunctionName modelo ([lista arg])  classe ClassName {{...}} -