10 Maneiras de evitar erros em C ++ - manequins

É um fato infeliz que você passará mais tempo procurando e removendo erros do que gastará realmente escrevendo seus programas C ++ em primeiro lugar. As sugestões aqui podem ajudá-lo a minimizar o número de erros que você introduziu em seus programas para tornar a programação uma experiência mais agradável.

Ativar todos os avisos e mensagens de erro

A sintaxe do C ++ permite muitos erros de verificação. Quando o compilador encontra uma construção que simplesmente não pode decifrar, não tem escolha senão enviar uma mensagem. Ele tenta sincronizar backup com o código-fonte (às vezes menos que com sucesso), mas não gerará um executável. Isso força o programador a corrigir todas as mensagens de erro.

No entanto, quando o C ++ se depara com uma estrutura que pode descobrir, mas a estrutura cheira pesada de qualquer maneira, o C ++ gera uma mensagem de aviso. Como o C ++ tem certeza de que ele entende o que deseja, ele vai adiante e cria um arquivo executável para que você possa ignorar avisos se quiser. Na verdade, se você realmente não quiser ser incomodado, você pode desativar avisos.

Desativar ou ignorar os avisos é uma idéia extraordinariamente ruim. É um pouco como desconectar a luz do "controle do motor" no painel do carro, porque isso o incomoda. Ignorar o problema não faz desaparecer.

Adote um estilo de codificação claro e consistente

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

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

Um bom estilo de codificação permite fazer o seguinte com facilidade:

• Diferenciar os nomes das classes, os nomes dos objetos e os nomes das funções

• Compreender o que a classe, a função ou o objeto são usados ​​para, com base em seu nome

• Diferenciar símbolos de préprocessador de símbolos C ++ (ou seja, os objetos #define devem se destacar)

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

Em Além disso, você precisa estabelecer um formato padrão para os cabeçalhos de seus módulos que fornece informações sobre as funções ou classes em cada módulo, o autor, a data, a versão e algo sobre o histórico de modificações.

Todos os programadores envolvidos em um único projeto devem usar o mesmo estilo de codificação. Um programa escrito em um patchwork de diferentes estilos de codificação é confuso e parece não profissional.

Comente o código enquanto você o escreve

Você pode evitar erros se você comentar seu código enquanto o escreve, em vez de esperar até que tudo funcione e depois voltar e adicionar comentários.

Formulando comentários obriga você a fazer um balanço do que está tentando fazer. Comentários curtos são esclarecedores, tanto quando você lê-los mais tarde quanto você os está escrevendo. Escreva comentários como se estivesse falando com outro programador experiente.

Etapa única em cada caminho no depurador pelo menos uma vez

Como programador, você precisa entender o que seu programa está fazendo. Não é suficiente que o programa exiba 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 um único passo o programa, executando-o passo a passo com um bom depurador (como aquele que vem com o Código:: Blocos).

Além disso, ao depurar um programa, você precisa de matéria-prima para descobrir algum comportamento estranho que possa surgir à medida que o programa é executado. Nada lhe dá esse material melhor do que um único passo em cada função à medida que entra em serviço.

Finalmente, quando uma função está concluída e pronta para ser adicionada ao programa, cada caminho lógico deve ser percorrido pelo menos uma vez. Os erros são muito mais fáceis de encontrar quando você examina a função por si só, em vez de ter sido jogada no pote com o resto das funções - até então, sua atenção passou a novos desafios de programação.

Limite a visibilidade

Limitar a visibilidade dos elementos internos da classe ao mundo exterior é uma pedra angular da programação orientada a objetos. A classe deve ser responsável pelo seu estado interno - se algo for ferrado na classe, então é culpa do programador da classe. O programador da aplicação deve se preocupar em resolver o problema em questão.

Especificamente, a visibilidade limitada significa que os membros dos dados não devem estar acessíveis fora da classe - ou seja, devem ser marcados como protegidos. Além disso, as funções dos membros que o software aplicativo não precisa saber também devem ser marcadas como protegidas. Não exponha mais os internos da classe do que o necessário para fazer o trabalho.

Mantenha o controle da memória heap

Perder faixa da memória heap é a fonte mais comum de erros fatais em programas que foram lançados no 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 nos programas que você compra). Você pode ter que executar um programa por horas antes de os problemas começarem a surgir (dependendo de quão grande seja o vazamento de memória).

Como regra geral, os programadores devem sempre alocar e liberar memória de heap no mesmo nível ". "Se uma função de membro MyClass:: create () aloca um bloco de memória de heap e retorna ao chamador, então deve haver um membro MyClass:: release () que o devolve ao heap.Especificamente, MyClass:: create () não deve exigir que a função pai libere a memória.

Se possível, MyClass deve acompanhar esses ponteiros de memória por conta própria e excluí-los no destruidor.

Zero para fora dos ponteiros depois de excluir o que eles apontam para

Certifique-se de que você exclua os ponteiros depois que eles não são mais válidos; você faz isso atribuindo-lhes o valor nullptr. Os motivos dessa ação ficam claros com a experiência: você pode continuar usando um bloco de memória que foi retornado ao heap e nem sequer o conhece. Um programa pode funcionar bem 99% do tempo, tornando muito difícil encontrar o 1% dos casos em que o bloco é reafectado e o programa não funciona.

Se você anular os ponteiros que não são mais válidos e você tenta usá-los para armazenar um valor (você não pode armazenar nada em ou perto da localização nula), seu programa será interrompido imediatamente. Crashing soa mal, mas não é se isso expõe um problema. O problema está lá; É apenas uma questão de saber se você encontra ou não antes de colocá-lo em produção.

Use exceções para lidar com erros

O mecanismo de exceção em C ++ foi projetado para lidar com erros de forma conveniente e eficiente. Em geral, você deve lançar 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 esperam, e você não gostaria de decepcioná-los, você faria?

Limite o uso de exceções para erros verdadeiros. Não é necessário lançar uma exceção de uma função que retorna um indicador "não funcionou" se isso for parte da vida cotidiana para essa função.

Declare destructors virtual

Não se esqueça de criar um destruidor para a sua classe se o construtor alocar recursos, como a memória de heap, que precisam ser retornados quando o objeto atinge sua queda definitiva. Tendo criado um destruidor, não se esqueça de declará-lo virtual.

"Mas", você diz, "minha classe não herda de nada, e não é subclassada por outra classe. "Sim, mas poderia se tornar uma classe base no futuro. A menos que você tenha algum bom motivo para não declarar o destruidor virtual, então faça isso quando você cria a classe pela primeira vez.

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

Se sua classe precisar de um destruidor, quase certamente precisa de um construtor de cópia e um operador de atribuição sobrecarregado. Se o seu construtor alocar recursos como a memória de heap, o construtor de cópia e o operador de atribuição padrão não farão nada além de criar havoc, gerando vários ponteiros para os mesmos recursos.

Quando o destruidor de um desses objetos é invocado, ele irá restaurar os recursos. Quando o destrutor para a outra cópia vier, ele vai arrumar as coisas.