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

Parte de C ++ para Dummies Cheat Sheet

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

Expressões

As expressões tomam uma das seguintes formas:

objName // para uma expressão de operador de objeto simples // para operadores unários expr1 operador expr2 // para operadores binários expr1? expr2: expr3 // para o operador ternário funcName ([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 definidos na tabela a seguir.

Exemplo	Tipo
1	int
1L	int longo
1LL	longo longo int
1. 0	duplo
1. 0F	float
'1'	char
"uma string"	char * (terminado automaticamente com um caractere nulo)
L "uma string"	wchar_t * > u8 "esta é uma string UTF-8 com um caractere UTF-8: u2018"
char8_t *	u "esta é uma string UTF-16 com um caractere UTF-16: u2018"
char16_t *	U "esta é uma string UTF-32 com um caractere UTF-32:
U00002018" char32_t *	true, false
bool	0b101
binário (C ++ 2014 padrão)

Declarações

As declarações utilizam tipos intrínsecos e definidos pelo usuário. Os tipos intrínsecos são

[] char [] wchar_t [] [] int float [long] double bool

As declarações possuem uma das seguintes formas:

[] [const] type var [= expressão]; // variável [] [const] tipo array [size] [= {list}]; // array [const] type object [(lista de argumentos)]; // objeto [const] tipo objeto [= {lista de argumentos}]; // tipo alternativo [const] * [const] ptr [= expressão do ponteiro]; // tipo de ponteiro & refName = objeto; // tipo de referência fnName ([lista de argumentos]); // função

A palavra-chave auto pode ser usada se o C ++ puder determinar o próprio tipo de variável:

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

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

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

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

// função simples [] tipo fnName (lista de argumentos) {…} // função de membro definida fora da classe [inline] tipo Classe:: func (lista de argumentos) [const] {…} // construtor / destrutores também podem ser definidos fora da classe Classe:: Classe ([lista de argumentos]) {…} Classe:: ~ Classe () {… } // construtores / destrutores podem ser excluídos ou inadimplentes // em vez de definição Classe:: Classe ([lista de argumentos]) =; Classe:: ~ Classe () =;

Um operador sobrecarregado parece uma definição de função.A maioria dos operadores sobrecarregados pode ser escrita como membro ou funções simples. Quando escrito como uma função de membro, * este é o primeiro argumento assumido para o operador:

MyClass & operator + (const MyClass & m1, const MyClass & m2); // Simple MyClass & MyClass:: operador + (const MyClass & m2); // membro;

Os usuários também podem definir seus próprios tipos usando as palavras-chave de classe ou estrutura:

ClassName [: [virtual] [public] BaseClass] {: // construtor ClassName ([arg list]) ClassName () [=;] // destruidor [virtual] ~ ClassName () <{…} | [=; > // membros de dados públicos tipo dataMemberName [= initialValue]; // funções do membro público tipo memberFunctionName ([arg list]) [{…}] // const member function type memberFunctionName ([arg list]) const [{…}] // virtual member functions tipo virtual memberFunctionName ([arg list]) [{…}]; // funções de membro virtual puro, tipo virtual memberFunctionName ([arg list]) = 0; // função que deve substituir um tipo de função de classe base memberFunctionName ([arg list]) override; // uma função que não pode ser superada em um tipo de subclasse memberFunctionName ([arg list]) final;};

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

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

enum STATE {DC, // obtém 0 ALABAMA, // obtém 1 ALASKA, // obtém 2 ARKANSAS, // obtém 3 // … e assim por diante}; int n = ALASKA; // ALASKA é do tipo int

Por padrão, uma entrada individual é de tipo int, mas isso pode ser alterado no padrão C ++ 2011:

enum ALPHABET: char {A = 'a', // obtém 'a' B, // obtém 'b' C, // obtém 'c' // … e assim por diante}; char c = A; // A é do tipo char

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

// a enumeração a seguir define um novo tipo STATE enum classe ESTADO {DC, // obtém 0 ALABAMA, // obtém 1 ALASKA, // obtém 2 ARKANSAS, // obtém 3 // … e assim por diante}; ESTADO s = ESTADO:: ALASKA; // agora STATE é um novo tipo // o seguinte usa uma classe de enumeração de tipo subjacente diferente ALPHABET: char {A = 'a', // obtém 'a' B, // obtém 'b' C, // obtém 'c ' //… e assim por diante}; ALFABETO c = ALFABETO:: A; // A é do tipo ALPHABET

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

// tipo T é fornecido pelo programador no tipo de modelo de uso FunctionName ([arg list]) classe de modelo ClassName {{…}};