10 Maneiras de evitar erros em c ++

É um fato lamentável que você vai gastar mais tempo procurando e eliminando erros 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.

Video: Solución al error Microsoft Visual C++ Runtime Library windows 7 y 8

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 a não ser saída 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 ++ é quase certeza que ele entende 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 os avisos.

Desativar ou de outra forma avisos ignorando é um extraordinariamente má idéia. É um pouco como desligar a luz “check engine” 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

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 um pouco surpreendente de coisas resulta do fato de que nossos cérebros têm apenas uma quantidade limitada de poder de computação.

Quando você ler 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 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 classes, nomes de objetos e nomes de função

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

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

• Identificar blocos de código C ++, ao mesmo nível (isto é 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 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ê estivesse conversando com outro, programador experiente.

De uma etapa cada caminho 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 um único piso o programa, executá-lo passo a passo com um bom depurador (como o 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 está terminado e pronto para ser adicionado ao programa, cada caminho lógico precisa ser percorrida 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 de 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 algo é asneira na classe, então é 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 deve ser acessível fora da classe - ou seja, eles devem ser marcados como protegidos. Além disso, as funções de membro de que a aplicação 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. (Como essa 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 devem sempre alocar e liberar memória heap no mesmo “nível”. Se uma função 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- você fizer isso, atribuindo-lhes o valor nullptr. As razões para esta 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 fica realocados eo programa não funciona.

Se nulo fora ponteiros que já não são válidos 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. Crashing soa mal, mas não é se ele 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 excepção no C ++ é desenhado 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-lo, e você não gostaria de decepcioná-los, não é?

Limitar o uso de exceções para os verdadeiros erros. Não é necessário para lançar uma exceção de uma função que retorna um indicador “não funcionou”, se esta é uma parte da vida cotidiana para essa função.

Declarar destruidores virtuais

Não se esqueça de criar um processo de destruição para a 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.

“Mas”, você diz, “minha classe não herda de qualquer coisa, e não é uma subclasse de outra classe.” Sim, mas poderia tornar-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.

Video: Como arrumar o erro "Crash Dumps" FM2016 (2° Método!)

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.