Início Programação com C ++ Para Dummies Cheat Sheet - dummies

Por Stephen R. Davis

C ++ não é uma linguagem de programação fácil de dominar. Somente através da experiência, a infinidade de combinações de símbolos começará a parecer natural para você. Esta Cheat Sheet, no entanto, dá-lhe algumas dicas sólidas sobre como facilitar a transição do iniciante C ++ para o Guru C ++: saiba como ler expressões complexas do C ++; Saiba como evitar problemas de ponteiro; e descobrir como e quando fazer cópias profundas.

Como ler uma expressão complexa de C ++

C ++ está cheio de pequenos símbolos, cada um dos quais aumenta o significado das expressões. As regras da gramática de C ++ são tão flexíveis que esses símbolos podem ser combinados em combinações praticamente impenetrivelmente complexas. As expressões na linguagem C mais simples podem ficar tão obtusas que costumava haver um concurso anual para quem poderia escrever o programa mais obscuro e quem poderia entender isso.

Nunca é uma boa idéia tentar escrever um código complexo, mas às vezes você pode executar as expressões em C ++ que são um pouco desconcertantes à primeira vista. Basta usar as seguintes etapas para descobrir:

1. Comece nos parênteses mais incorporados.

   Comece a procurar o parêntese mais externo. Dentro desses, procure parênteses incorporados. Repita o processo até que você tenha trabalhado o caminho para os parênteses mais profundos. Comece a avaliar essa subexpressão primeiro usando as seguintes regras. Depois de entender essa expressão, volte para o próximo nível e repita o processo.

2. No par de parênteses, avalie cada operação em ordem de precedência.

   A ordem em que os operadores são avaliados é determinada pela precedência do operador mostrada na tabela. A indicação vem antes da multiplicação que vem antes da adição, assim o seguinte adiciona 1 mais 2 vezes o valor apontado por * ptr.

int i = 1 + 2 * * ptr;

Operadores em ordem de precedência

Precedência	Operador	Significado
1	() (unary)	Invoca uma função
2	* e -> (unary)	Dereference um ponteiro
2	- (unary)	Retorna o negativo de seu argumento
3	++ (unary)	Incremento
3 > - (unary)	Decreado	4
* (binário)	Multiplicação	4
/ (binário)	Divisão	4
% (binário)	Modulo	5
+ (binário)	Adição	5
- (binário)	Subtração	6
&& (binário)	Logical AND	6
! !	OR lógico	7
=, * =,% =, + =, - = (especial)	Tipos de atribuição	Avalie operações do mesmo precedente da esquerda para a direita (exceto atribuição, que vai para o outro lado).

1. A maioria dos operadores da mesma prioridade avalia da esquerda para a direita. Assim, o seguinte adiciona 1 a 2 e adiciona o resultado a 3:

   int i = 1 + 2 + 3;

   A ordem de avaliação de alguns operadores não importa. Por exemplo, a adição funciona da mesma maneira da esquerda para a direita, assim como da direita para a esquerda. A ordem de avaliação faz muita diferença para algumas operações, como a divisão. O seguinte divide 8 por 4 e divide o resultado em 2:
   

   int i = 8/4/2;

   A principal exceção a esta regra é a atribuição, que é avaliada da direita para a esquerda:
   

   a = b = c;

   Isso atribui c para b e o resultado para a.
   

   Avalie subexpressões em nenhuma ordem específica.

2. Considere a seguinte expressão:

   int i = f () + g () * h ();

   A multiplicação tem precedência mais alta, então você pode assumir que as funções g () e h () são chamadas antes de f (), no entanto, esse não é o caso. A chamada de função tem o precedente mais alto de todos, então todas as três funções são chamadas antes da multiplicação ou adição. (Os resultados retornados de g () e h () são multiplicados e depois adicionados aos resultados retornados de f ().)
   

   A única vez que a ordem em que as funções são chamadas faz a diferença é quando a função tem efeitos colaterais como abrir um arquivo ou alterar o valor de uma variável global. Você definitivamente não deve escrever seus programas para que eles dependam desse tipo de efeitos colaterais.

   Execute quaisquer conversões de tipo somente quando necessário.

3. Você não deve fazer mais conversões de tipo do que o absolutamente necessário. Por exemplo, a seguinte expressão tem pelo menos três e possivelmente quatro conversões de tipo:

   flutuante f = 'a' + 1;

   O char 'a' deve ser promovido para um int para executar a adição. O int é convertido em um duplo e depois convertido em um único flutuador de precisão. Lembre-se de que toda a aritmética é realizada em int ou em duplo. Em geral, você deve evitar a realização de aritmética em tipos de caracteres e evitar um único flutuador de precisão.
   

   5 maneiras de evitar problemas de ponteiro em C ++

Em C ++, um marcador

é uma variável que contém o endereço de um objeto na memória interna do computador. Use estas etapas para evitar problemas com ponteiros em C ++: Inicialize ponteiros quando declarado.

1. Nunca deixe as variáveis ​​do ponteiro não inicializadas - as coisas não seriam muito ruins se os ponteiros não inicializados continham valores aleatórios - a grande maioria dos valores aleatórios são valores de ponteiro ilegais e fará com que o programa falhe assim que eles são usados. O problema é que as variáveis ​​não inicializadas tendem a assumir o valor de outras variáveis ​​de ponteiro usadas anteriormente. Esses problemas são muito difíceis de depurar.

   Se você não sabe o que mais para inicializar um ponteiro, inicialize-o para nullptr. nullptr é garantido para ser um endereço ilegal.

   Zero out pointers depois de usá-los.

2. Da mesma forma, sempre zero uma variável ponteiro uma vez que o ponteiro não é mais válido, atribuindo-lhe o valor nullptr. Este é particularmente o caso quando você retorna um bloco de memória ao heap usando delete; sempre zero o ponteiro depois de retornar a memória do heap.

   Alocar a memória do heap e devolvê-lo ao heap no mesmo "nível" para evitar vazamentos de memória.

3. Sempre tente retornar um bloco de memória ao heap com o mesmo nível de abstração que você alocou. Isso geralmente significa tentar eliminar a memória no mesmo nível de chamadas de função.

   Trave uma exceção para excluir a memória quando necessário.

4. Não esqueça que uma exceção pode ocorrer em quase qualquer momento. Se você pretende capturar a exceção e continuar a operar (em oposição a deixar o programa falhar), certifique-se de pegar a exceção e retornar qualquer bloco de memória ao heap antes que os ponteiros que os apontarem saem do escopo e a memória é perdido.

   Certifique-se de que os tipos correspondem exatamente.

5. Certifique-se sempre de que os tipos de ponteiros correspondem ao tipo desejado. Não reformule um ponteiro sem algum motivo específico. Considere o seguinte:

   void fn (int * p); anular myFunc () {char c = 'a'; char * pC = & c; fn ((int *) pC);}

A função acima compila sem queixa, uma vez que o ponteiro de caracteres pC foi reformulado para um int * para coincidir com a declaração de fn (int *); No entanto, este programa quase certamente não funcionará. A função fn () está esperando um ponteiro para um inteiro inteiro de 32 bits e não um pouco de rinky-dink 8 bit char. Esses tipos de problemas são muito difíceis de resolver.

Como e quando fazer cópias profundas em C ++

As classes que alocam recursos em seu construtor normalmente devem incluir um construtor de cópia para criar cópias desses recursos. Atribuir um novo bloco de memória e copiar o conteúdo do original para este novo bloco é conhecido como criar uma

cópia em profundidade (em oposição à cópia rasa padrão). Use as seguintes etapas para determinar como e quando fazer cópias profundas em C ++: Faça sempre uma cópia profunda se o construtor alocar recursos.

1. Por padrão, o C ++ faz as chamadas cópias "rasas" de membros por membros de objetos ao passar para funções ou como resultado de uma tarefa. Você deve substituir os operadores de cópia superficial padrão com seu equivalente de cópia profunda para qualquer classe que aloque recursos no construtor. O recurso mais comum que é alocado é a memória de heap que é retornada pelo novo operador.

   Sempre inclua um destruidor para uma classe que aloca recursos.

2. Se você criar um construtor que aloca recursos, você deve criar um destruidor que os restaure. Sem exceções.

   Declarar sempre o destruidor virtual.

3. Um erro comum para iniciantes é esquecer de declarar seu destruidor virtual. O programa funcionará bem até que algum programador desavisado venha e herda da sua classe. O programa ainda parece funcionar, mas porque o destrutor na classe base não pode ser invocado corretamente, vazamentos de memória do seu programa como uma peneira até que ele eventualmente falha. Este problema é difícil de encontrar.

   Inclua sempre um construtor de cópia para uma classe que aloca recursos.

4. O construtor de cópia cria uma cópia adequada do objeto atual alocando a memória fora do heap e copiando o conteúdo do objeto de origem.

   Substitua sempre o operador de atribuição por uma classe que aloca recursos.

5. Os programadores devem ser desencorajados dos operadores superiores, mas o operador de atribuição é uma exceção. Você deve substituir o operador de atribuição por qualquer classe que aloque recursos no construtor.

   O operador de atribuição deve fazer três coisas:

   Certifique-se de que o objeto da mão esquerda e direita não são o mesmo objeto. Em outras palavras, certifique-se de que o programador de aplicativos não escreveu algo como (a = a). Se o fizerem, não façam nada.

   1. Invoque o mesmo código que o destrutor no objeto esquerdo para retornar seus recursos.

   2. Invoque o mesmo código como um construtor de cópia para fazer uma cópia profunda do objeto da mão direita no objeto da mão esquerda.

   3. Se você não pode fazer isso, exclua o construtor de cópia e o operador de atribuição para que o programa não possa fazer cópias do seu objeto.

6. Se você ainda não pode fazer isso porque seu compilador não suporta o recurso do construtor de exclusão C ++ 2011, crie um construtor de cópia vazio e um operador de atribuição e declare-os protegidos para evitar que outras classes os usem.