10 maneiras de evitar erros em C ++

É um fato lamentável que você vai gastar mais tempo procurando e remoção de bugs do que você vai gastar realmente escrever o seu C ++ programas em primeiro lugar. As sugestões aqui pode ajudá-lo a minimizar o número de erros que você introduzir em seus programas para tornar a programação uma experiência mais agradável.

Permitir que todos os avisos e mensagens de erro

A sintaxe do C ++ permite um monte de verificação de erros. Quando o compilador encontra uma construção que ele simplesmente não consegue decifrar, ele não tem escolha, mas para saída de uma mensagem. Ele tenta sincronizar de volta com o código-fonte (por vezes menos de sucesso), mas não irá gerar um executável. Isso força o programador para corrigir todas as mensagens de erro.

No entanto, quando C ++ vem através de uma estrutura que possa descobrir, mas a estrutura cheira bem de qualquer maneira, C ++ gera uma mensagem de aviso. Porque C ++ é bastante certeza de que ele compreende o que você quer, ele vai em frente e cria um arquivo executável para que você possa ignorar os avisos, se quiser. Na verdade, se você realmente não quer ser incomodado, você pode desativar avisos.

Desativar ou de outra forma ignorar avisos, é uma extraordinária má idéia. É um pouco como desligar o # 147-check engine # 148- luz no painel de instrumentos do seu carro porque ele incomoda. Ignorar o problema não torná-lo ir embora.

Adote um estilo de codificação clara e consistente

Escrevendo seu código C ++ em um estilo claro e consistente, não só melhora a legibilidade do programa, mas também resulta em menos erros de codificação. Este estado um tanto surpreendente de coisas resulta do fato de que nossos cérebros têm apenas uma quantidade limitada de poder de computação.

Quando você lê o código que é limpo e arrumado e que segue um estilo que você está familiarizado com, você gasta muito pouca energia cerebral analisar a sintaxe das instruções de C ++. Isso deixa mais poder de CPU cérebro para decodificar o que o programa está tentando fazer e não como ele está fazendo isso.

Um estilo de codificação bom permite que você faça o seguinte com facilidade:

• Diferenciar entre nomes de classe, nomes de objetos e nomes de função

• Entenda o que a classe, função ou objeto é usado para, com base no seu nome

• Diferenciar símbolos de pré-processamento de símbolos C ++ (isto é, #definir objetos devem se destacar)

• Identificar blocos de código C ++ no mesmo nível (este é o resultado de recuo consistente)

Além disso, é necessário estabelecer um formato padrão para seus cabeçalhos módulo que fornece informações sobre as funções ou classes em cada módulo, o autor, a data, a versão, e algo sobre a história modificação.

Todos os programadores envolvidos em um único projeto deve usar o mesmo estilo de codificação. Um programa escrito em uma colcha de retalhos de diferentes estilos de codificação é confuso e parece pouco profissional.

Comentar o código enquanto você escrevê-lo

Você pode evitar erros se você comentar o seu código enquanto você escrevê-lo, ao invés de esperar até que tudo funciona e, em seguida, voltar e adicionar comentários.

Formular comentários obriga a fazer um balanço do que é que você está tentando fazer. breves comentários são esclarecedoras, tanto quando você lê-los mais tarde e como você está escrevendo-los. Escrever comentários como se você está falando com outro, programador experiente.

De um único passo todos os caminhos no depurador pelo menos uma vez

Como um programador, você tem que entender o que seu programa está fazendo. Não é suficiente que o programa gera o valor esperado. Você precisa entender tudo o que seu programa está fazendo. Nada lhe dá uma sensação melhor para o que está acontecendo sob o capô do que single-stepping o programa, executá-lo passo a passo com um bom depurador (como aquele que vem com Code :: Blocks).

Além disso, como você depurar um programa, você precisa de matéria-prima para descobrir algum comportamento bizarro que pode surgir como o programa é executado. Nada dá-lhe que o material melhor do que um único percorrendo cada função, uma vez que entra em serviço.

Finalmente, quando uma função é acabado e pronto para ser adicionado ao programa, cada caminho lógico precisa ser explorada, pelo menos, uma vez. Erros são muito mais fáceis de encontrar quando você examinar a função por si só, em vez de depois de ter sido jogado na panela com o resto das funções - até então, sua atenção passou a novos desafios de programação.

Limitar a visibilidade

Limitando a visibilidade dos internos de classe para o mundo exterior é uma pedra angular da programação orientada a objeto. A classe deve ser responsável por seu estado interno - se alguma coisa fica asneira na classe, então a culpa é do programador classe. O programador da aplicação deve se preocupar sobre como resolver o problema na mão.

Especificamente, a visibilidade limitada significa que os membros de dados não devem ser acessíveis fora da classe - ou seja, eles devem ser marcados como protegidos. Além disso, as funções de membro que o software aplicativo não precisa saber sobre o também deve ser marcado protegida. Não exponha mais dos internos de classe do que o necessário para começar o trabalho feito.

Mantenha o controle de memória heap

Perder o controle de memória heap é a fonte mais comum de erros fatais em programas que foram lançados para o campo - e, ao mesmo tempo, o problema mais difícil de rastrear e remover. (Porque esta classe de erro é tão difícil de encontrar e remover, é prevalente em programas que você compra.) Você pode ter que executar um programa para horas antes que os problemas começam a surgir (dependendo de quão grande é o vazamento de memória é).

Como regra geral, os programadores deve sempre alocar e liberar memória heap, ao mesmo # 147 de nível. # 148- Se uma função de membro MyClass :: create () aloca um bloco de memória heap e retorna para o chamador, então não deve ser um membro MyClass :: release () que retorna para o heap. Especificamente, MyClass :: create () não deve exigir a função de pai para liberar a memória.

Se tudo for possível, Minha classe deve manter o controle de tais ponteiros de memória por conta própria e excluí-los no processo de destruição.

Zero ponteiros fora depois de eliminar o que eles apontam para

Certifique-se de zerar os ponteiros depois que eles não são mais valid- fazê-lo, atribuindo-lhes o valor nullptr. As razões para essa ação tornar-se claro com a experiência: Você pode continuar a usar um bloco de memória que tenha sido devolvido para a pilha e não sabe mesmo. Um programa pode correr bem 99 por cento do tempo, tornando-se muito difícil encontrar a 1 por cento dos casos em que o bloco se realocados eo programa não funciona.

Se você nulo fora ponteiros que não são mais válidas e você tentar usá-los para armazenar um valor (você não pode armazenar qualquer coisa em ou perto do local null), o programa irá falhar imediatamente. Falhando soa mal, mas não é se expõe um problema. O problema é lá- é apenas uma questão de saber se você encontrá-lo ou não antes de colocá-lo em produção.

Use exceções para lidar com erros

O mecanismo de exceção em C ++ é projetado para lidar com erros de forma conveniente e eficiente. Em geral, você deve jogar um indicador de erro, em vez de retornar um sinalizador de erro. O código resultante é mais fácil de escrever, ler e manter. Além disso, outros programadores têm vindo a esperar, e você não gostaria de decepcioná-los, não é?

Limitar o uso de excepções a verdadeiros erros. Não é necessário para lançar uma exceção de uma função que retorna um # 147-não trabalho # 148- indicador se isso é uma parte da vida cotidiana para essa função.

Declarar destruidores virtuais

Não se esqueça de criar um destruidor para sua classe se o construtor aloca recursos, como memória heap que precisam ser devolvido quando o objeto atinge o seu desaparecimento final. Tendo criado um destruidor, não se esqueça de declará-la virtual.

# 147 Mas, # 148- você diz, # 147-minha classe não herda de qualquer coisa, e não é uma subclasse de outra classe. # 148- Sim, mas poderia -se uma classe base no futuro. A menos que tenha uma boa razão para não declarar o destruidor virtual, em seguida, fazê-lo quando você criar a classe.

Fornecer um construtor de cópia e operador de atribuição sobrecarregado

Se sua classe precisa de um destrutor, quase certamente precisa de um construtor de cópia e um operador de atribuição sobrecarregado. Se o seu construtor aloca recursos, como memória heap, o construtor de cópia padrão e operador de atribuição não fará nada, mas criar o caos, gerando vários ponteiros para os mesmos recursos.

Quando o destruidor para um desses objetos é invocado, ele irá restaurar os ativos. Quando o destruidor para a outra cópia vem, ele vai estragar tudo.