Já trabalhei em várias equipes, algumas tinham um cuidado extremo com a gestão da alocação de memória, outras não se preocupavam tanto assim. Independente da atitude da equipe é importante saber como evitar vazamentos, e quais as consequências.

Para quem não sabe o que é vazamento de memória: é a manutenção de memória alocada dinamicamente após seu uso de forma que não possa ser recuperada, utilizada ou desalocada. O mesmo pode-se dizer de outros recursos. O programa funciona perfeitamente, porém em algum momento a memória acaba, e aí começam os problemas.

Recentemente orientei um participante da lista ccppbrasil com um exercício que ele estava tentando fazer. E dentre as soluções que eu sugeri tinha a opção dele criar uma calculadora RPN utilizando C. Pra quem não sabe como funciona uma calculadora RPN (Notação Polonesa Reversa), pode dar uma olhada neste link.

Na verdade o rapaz queria fazer parse de álgebra direta, eu orientei fazer uma RPN com uma pilha de 2 variáveis, x e y. E agora eu desenvolvi a solução e decidi disponibilizar. Vamos a primeira opção:

O conceito é simples, mas muita gente não sabe. A diferença básica entre os operadores de incremento pré-fixados e pós-fixados é o momento em que os valores são resolvidos. No caso dos pré-fixados a execução do incremento/decremento se dá antes da resolução do resultado; no pós-fixado o incremento/decremento se dá depois da resolução do resultado. Assim, o código abaixo:

int x = 10;
int y = 10;
printf("Antes do pre-fixado: %d\n", x);
printf("Durante o pre-fixado: %d\n", ++x);
printf("Apos o pre-fixado: %d\n", x);

printf("Antes do pos-fixado: %d\n", y);
printf("Durante o pos-fixado: %d\n", y++);
printf("Apos o pos-fixado: %d\n", y);

É comum programadores C/C++ com certa experiência não saberem como exatamente funciona o loop for. A maioria aprende um paralelo entre o For-To-Next e o for e não fica sabendo do verdadeiro poder do for em C/C++.

Veja o exemplo abaixo que valida a versão de um conjunto de nós:

for (ctnode = nnodes; ctnode--; )
    if (strcmp(refversion, nodes[ctnode].version)
        break;
if (ctnode >= 0)
    TRACE(TRACE_ERROR, "Not all nodes in same version, aborting");

Tratamento de erros em C pode se tornar um problema. É muito fácil se perder um conjuntos de ifs aninhados, aumentando cada vez mais a interpretação do código, dificultando, consequentemente, sua manutenção. Vamos ver um exemplo:

Trabalhei com uma equipe que tinha o costume de fazer traces da seguinte forma:

char *logtrace = ::getenv("LOGTRACE");
// ...
if (logtrace) std::cout << "*** Starting CUtil::promoteSale ***" << std::endl
if (logtrace) std::cout << "* Arg saleID: " << saleID << std::endl;
if (logtrace) std::cout << "* Arg owner: " << owner << std::endl; 

De acordo com uma notíca no ZDNet, uma estatística feita pelo Google indica que 70% das falhas de segurança do Google Chrome estão relacionadas com problemas de gerenciamento de memória. A Microsoft publicou resultados equivalentes em seus produtos.

Em ambos os casos a base de códigos predominante é C e C++, linguagens que não tem mecanismos de gestão de memória, deixando para o desenvolvedor a responsabilidade de gerenciar os ponteiros e as memórias.

Por isso a importância de se conhecer apropriadamente C e C++, e não simplesmente achar que sabendo a sintaxe sabe-se programar. Código de qualidade reduz o retrabalho, aumenta a segurança, e principalmente a estabilidade do programa desenvolvido.

Out-of-bounds pode ser traduzido com fora dos limites, mas a expressão array out-of-bounds significa acessar um array além do seu limite inferior ou superior, outro nome muito popular é array overflow, ou string overflow.

Nas linguagens C/C++ não há checagem de limites para arrays simples, o compilador deixa o programador acessar a memória do jeito que bem entender, e a responsabilidade de não estourar os limites é do próprio programador.

Quando isso acontece o compilador simplesmente começa a acessar a memória contígua à memória alocada para o array, provavelmente outras variáveis.

Já vi muita gente que sabe orientação a objetos, programa bem em C++, usa STL, mas na hora de formatar a saída utiliza printf.

Quem aprendeu C antes de aprender C++ normalmente prefere utilizar printf para formatar a saída. Com printf vai bem, mas e se a saída for num arquivo? E se os padrões de desenvolvimento da equipe exigir a utilização de std::cout? Pra isso que devemos conhecer as funções de formatação do iomanip.