C ++ for Dummies

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.

Conteúdo

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.

ExemploDigitar
1int
1Llong int
1LLint long long
1.0duplo
1.0Fflutuador
'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 falsobool
0b101biná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 {{...}} -

Programação operadores em C ++

Todos os operadores em C ++ executar alguma função definida. Esta tabela mostra o operador, a precedência (que determina quem vai primeiro), cardinalidade e associatividade no programa C ++.

Operadorcardinalityassociatividade
maior precedência() [] ->.unárioda esquerda para direita
! ~ + - ++ - * (Elenco) sizeofunárioda esquerda para direita
* /%binárioda esquerda para direita
+ -binárioda esquerda para direita
lt; lt; >>binárioda esquerda para direita
lt; lt; =>> =binárioda esquerda para direita
==! =binárioda esquerda para direita
binárioda esquerda para direita
^binárioda esquerda para direita
|binárioda esquerda para direita
binárioda esquerda para direita
||binárioda esquerda para direita
?:ternáriodireita para esquerda
= * = / =% = + = - = = ^ = | = lt; lt; = >> =bináriodireita para esquerda
menor precedência,binárioda esquerda para direita

Controle de fluxo em C ++ Programming

As seguintes estruturas C ++ direcionar o fluxo de controle através do programa. Se você é um programador experiente, a função destas estruturas será familiar de outras línguas.

E SE

Os seguintes avalia comando booleanExpression. Se é avaliada como verdade, em seguida, o controlo passa para expressions1. Se não, então o controlo passa para o opcional expressions2.

if (ExpressãoBooleana) {expressions1 -} [else {expressions2-}]

ENQUANTO

Os seguintes avalia comando booleanExpression. Se este for avaliada como verdade, em seguida, o controlo passa paraexpressões. No final do bloco, o controlo passa para trás ExpressãoBooleana e repete o processo.

while (ExpressãoBooleana) {} Expressões do

DO nº 133-ENQUANTO

Os seguintes comando é executado expressões. Em seguida, ele avalia ExpressãoBooleana. Se este for avaliada como True, o controle retorna ao topo do circuito e repete o processo.

fazer {Expressões do} while (ExpressãoBooleana) -

PARA

Os seguintes comando é executado initCommand que pode ser uma expressão ou uma declaração de variável. Em seguida, ele avalia expressaoBool. Se este for avaliada como verdade, em seguida, o controlo passa para expressions1. E se expressaoBool é falso, em seguida, o controle passa para a primeira declaração após a cinta fechada do para loop. Uma vez expressões concluída, o controle passa para a expressão contida no LoopExpression antes de voltar para expressaoBool para repetir o processo. E se initCommand declara uma nova variável, ele sai do escopo assim que o controle passa fora do loop.

for (initCommand- boolExpression- LoopExpression) {} Expressões do

PARA CADA)

O Standard 2011 apresenta uma segunda forma de para ciclo, por vezes conhecido como "para cada" por causa de sua semelhança com o para cada encontrado em alguns outros idiomas. Nesta forma, a variável declarada em declaração converte o valor do primeiro membro Lista e executa o expressões quadra. Quando concluída, a variável declarada leva o segundo valor de Lista e executa expressões mais uma vez. Este processo é repetido para cada valor Lista.

for (declaração: lista) {} Expressões do

INTERRUPTOR

Os seguintes avalia comando integerExpression e compara o resultado para cada um dos casos enumerados. Se o valor se encontra a ser igual a um dos valores integrais constantes, val1, val2, etc., o controle passa para o conjunto correspondente de expressões e continua até que o controle encontra um pausa. Se a expressão não for igual a nenhum dos valores, o controlo passa para o expressionsN Segue padrão.

switch (integerExpression) {case val1: expressions1-break-caso val2: expressions2-break-[padrão: expressionsN-]}

Tempo, continue, GOTO

UMA continuar passa o controlo para o fim da cinta fechada de qualquer um dos controlos looping. Isso faz com que o loop para continuar com a próxima iteração. Por exemplo, o ciclo seguinte processa números primos entre 1 e 20:

for (int i = 0- i lt; 20- i ++) {// se o número não é primo ... se) {// ... pular para o próximo valor de icontinue (isPrime (i!) -} // Avançar sobre o processamento}

UMA pausa passa o controle para a primeira declaração após a cinta fechada de qualquer um dos comandos de looping. Isto faz com que a execução para sair do ciclo imediatamente. Por exemplo, a seguir lê os caracteres até e é encontrado EOF:

while (true) {// ler uma linha de entrada objectinput >> line - // se uma falha ou fim-de-arquivo ocorre ... if (cin.eof () || cin.fail ()) {// ... em seguida, sair do LoopBreak -} // processo da linha}

UMA etiqueta Goto passa o controle para o rótulo fornecido. O exemplo a quebra acima poderia ter sido escrito como se segue:

while (true) {// ler uma linha de entrada objectinput >> line - // se uma falha ou fim-de-arquivo ocorre ... if (cin.eof () || cin.fail ()) {// ... em seguida, sair do exitLabel loopgoto -} // processo da linha} exitLabel: // controlo continua aqui