Atualizado pela última vez em fevereiro de 2021.
Para fazer um programa legível, é importante gastar algum tempo escolhendo bons nomes para os elementos do programa. Os nomes usados em um programa devem ser significativos, ou seja, deve ser possível entender o que é um elemento do programa pelo seu nome.
É comum que as pessoas aprendendo a programar queiram escolher qualquer nome para dedicar seu tempo à resolução do problema em si. Entretanto, é comum que a maior parte do tempo gasto no desenvolvimento de um programa esteja na depuração, ou seja, escrever o programa costuma demorar menos do que encontrar os motivos do programa estar errado e corrigí-los. Assim, um programa pouco legível vai dificultar o trabalho de encontrar erros, o tempo economizado na escolha de nomes acaba sendo gasto em maior quantidade depois da escrita.
Nomes significativos tendem a ser compridos e nenhum programador gosta de ficar escrevendo nomes compridos para tudo. Durante a aprendizagem de programação, é importante praticar a busca por meio termo entre legibilidade e tamanho. Com frequência é fácil pensar coisas como "esta é a altura do retângulo" e escolher nomes como altura ou retangulo. Nesse caso, qual dos dois nome é melhor? Dizer "esta é a altura" seria mais apropriado que dizer "este é o retângulo", de forma que altura é um nome melhor que "retângulo". Esse tipo de raciocínio para escolha de nomes não é difícil mas precisa ser praticado até ficar natural.
Uma outra estratégia prática é escrever um nome curto no início (como tam ao invés de tamanho) e ao final da escrita, antes da depuração do programa (ou antes da escrita de outro módulo), usar a IDE para trocar todos os identificadores tam por tamanho, de forma automática.
Programadores com formação forte em matemática têm tendência a escolher nomes que são compostos por uma única letra. Alguns exemplos de código apresentados na disciplina têm nomes de uma única letra tanto por este motivo, quanto pela questão da falta de espaço para produzir um programa que pode ser exibido num projetor, com letras grandes. Entretanto, com algumas exceções clássicas que serão apresentadas, nomes assim devem ser evitados. Quando você for olhar seu código para encontrar erros, é difícil lembrar que você chamou a quantidade de valores de m e o limite de t. Chame a quantidade de quantidade e o limite de limite.
Outra questão comum na escolha de identificadores é como juntar termos diferentes para produzir um identificador. Por exemplo: um programa precisa do "maior preço" em alguma de suas partes e o programador decidiu que precisa usar os dois termos em "maior preço", ao invés de usar só maior porque o programa também precisa do "maior volume de vendas" e portanto maior seria ambíguo. Não se pode usar espaços nos identificadores, então duas formas populares de juntar os termos são: maiorPreco e maior_preco. A primeira é frequentemente chamada de notação do camelo e a segunda de notação da cobra. As duas têm suas vantagens e desvantagens. O programador deve usar uma ou a outra, além de usar sempre a mesma notação ao longo de todo o programa, mas não pode usar maiorpreco. Juntar termos sem dar destaque à quais são os termos dificulta a leitura do código.
Em C++ as letras maiúsculas e minúsculas são consideradas diferentes nos identificadores, ou seja, os nomes altura, Altura e ALTURA são nomes diferentes. É útil definir regras sobre quando usar maiúsculas e quando usar minúsculas. Os professores não desejam impor regras sobre uso de maiúsculas e minúsculas, mas estarão atentos à presença ou ausência de um padrão. Um programa em que maiúsculas e minúsculas parecem ser alternadas sem qualquer motivo tende a ser considerado inferior a um programa em que existe uma regra de estilo.
Por exemplo: eu costumo escrever programas de tal forma que identificadores de variáveis sempre começam com letra minúsculas enquanto identificadores de outras coisas começam com letra maiúscula.
Bons nomes para variáveis são aqueles que remetem ao significado da informação armazenada na variável, em oposição a remeter ao processo de cálculo desenvolvido. São geralmente substantivos ou um substantivo com qualificadores. Ou seja, uma variável deve indicar qual informação ela guarda e não a forma como é a usada no processamento.
Os nomes mais difíceis de escolher são aqueles para informações auxiliares, ou seja, informações que não são parte do problema sendo resolvido em si, mas sim elementos que apareceram no programa apenas para permitir o uso dos comandos da linguagem. Essas variáveis, chamadas de variáveis auxiliares, devem ser evitadas, mas acabam sendo usadas com alguma frequência. Uma boa regra para eliminar variáveis é: se a informação é usada só uma vez depois de determinada, melhor não usar uma variável para armazená-la.
Constantes também devem ter nomes que representam a informação. É quase universal nos programas em C e em C++ que as constantes tenham nomes compostos exclusivamente por letras maiúsculas. Outras coisas não devem ter nomes compostos só por maiúsculas, isso facilita a identificação das constantes num programa.
Na linguagem C++ é comum que uma informação seja declarada como constante para indicar que "naquele trecho" do programa a informação não muda, em oposição a uma informação que não muda nunca (ao longo de toda a execução do programa). Esse tipo de constante costuma ter nome com o mesmo estilo das variáveis.
A composição de termos para formar identificadores é quase certa nos subprogramas. Novamente, recomenda-se o uso de um único estilo para todos os nomes. Esse estilo não precisa ser o mesmo que você vê nos subprogramas de bibliotecas. Ter um estilo diferente do usado nas bibliotecas ajuda a distinguir que foi feito por você e o que foi feito por terceiros.
Para os subprogramas que retornam valor (funções), recomenda-se usar nomes que representem a informação retornada (geralmente substantivo). Por exemplo: uma função que calcula a área de uma região poderia ser chamada de Area, e isto fica mais legível que termos verbais como CalcularArea porque a função vai ser escrita mais em lugares em a área (o resultado da execução) vai ser usado para alguma coisa.
As funções que retornam valores lógicos ficam bem nomeadas pela propriedade que verificam. Por exemplo: uma função que serve para verificar se um número é primo, retornando um valor lógico que diz se ele é primo ou não, pode ser chamada de Primo ao invés de VerificarPrimo.
Para os subprogramas que apenas alteram o estado das coisas (procedimentos), recomenda-se usar verbos no imperativo ou no infinitivo, porque o subprograma vai ser usado como se fosse um comando na sequência de comandos que é o programa. Então nomes como CalculeArea ou CalcularArea são melhores que substantivos como Area.
Registros são tipos de dados, portanto o nome de um registro deve indicar o tipo de informação guardada. O nome da variável declarada depois deve ser específico para uma informação. Ou seja, não confunda o tipo com a informação. O tipo deve ter um nome no singular, assim como os tipos int, float, char, double, bool, etc. são todos nomes no singular.
Os nomes para vetores podem ser no singular ou no plural porque se trata de uma variável que guarda várias informações. Usar no plural pode diminuir a legibilidade na hora do uso de itens do vetor, por exemplo: notas[i], mas usar no singular pode diminuir a legibilidade na hora do uso do vetor todo, por exemplo: float Maior(float valor[]). Usar um prefixo indicativo de vetor pode ajudar a manter o código legível, além de ajudar a indicar significado para a variável, depois de apresentado o assunto de ponteiros; por exemplo: return vetValores[i] ou float Maior(float vetValores[]). Não existe muito consenso a respeito da melhor forma, apenas decida e use sempre um mesmo estilo.
Para índices e iteradores é comum o uso do nome i, entretanto, eventualmente você vai precisar de outros nomes. Use modularização e declarações dentro de comandos para manter o escopo das variáveis tão pequeno quanto possível, evitando que qualquer pedaço do código necessite de atenção sobre vários índices ao mesmo tempo; dessa forma, todos pode se chamar i. Quando não for possível evitar mais de um índice importante na mesma parte do código, evite chamá-los de i, j, k, m, n, etc... Quanto mais nomes não significativos você usar num trecho de código, mais difícil vai ser corrigir e manter aquele código. Quando vários índices são importantes ao mesmo tempo, usar um nome que associa o índice ao conjunto de valores melhora a legibilidade. Por exemplo, a variável que indica qual o cliente num conjunto pode se chamar iCliente enquanto que a variável que indica o fornecedor pode se chamar iFornecedor.
Esta página é mantida por Bruno Schneider para a disciplina de IAlg