Rodrigo Strauss :: Blog

Programando melhor: padrão de nomenclatura

Padrão de nomenclatura é basicamente definir como serão nomeadas as funções, variáveis, classes e como formatar o código fonte. Isso não muda absolutamente nada no código de máquina gerado pelo compilador, mas faz toda a diferença para os programadores que fazem o software. Essa é uma discussão calorosa, com muita gente tentando explicar porque seu padrão/estilo é o melhor. E, como em quase todas as discussões calorosas, ninguém está certo. Nenhum padrão de nomenclatura é melhor do que o outro. Um padrão é um padrão, ele só precisa existir e ser funcional. Dito isso, algumas coisas devem ser consideradas.

É necessário ter um padrão de nomenclatura. Não importa se é camelCase ou FluFFersCasE, é importante definir uma padrão, nem que seja informal. Discuta entre os desenvolvedores e defina. Quase todas as linguagens tem um padrão recomendado por quem faz a linguagem, e é recomendável (mas não obrigatório) usá-lo para que o seu código siga o mesmo estilo das bibliotecas padrão. C# e Java são exemplos de linguagens com padrões bem definidos, enquanto C e C++ têm um padrão mais informal. Na Wikipedia existe uma lista boa sobre o que deve ser padronizado. Para C++ eu costumo usar o seguinte:

#define MACRO_DE_DEBUG printf

 //
 // comentários explicativos e com uma linha em branco em cima
 // e outra embaixo. Não usar comentários em bloco: /*  */
 // Isso dificulta comentar código já que não pode haver um 
 // comentário dentro do outro
 // 
class UmaClasse
{
  int m_variavelDeClasse;
  char* m_ponteiro;
  ClasseComConstrutor m_c1, m_c2;

  enum UmEnum
  { Item1, Item2, Item3, Item4 };

public:

 UmaClasse() :
   m_c1("abc"),
   m_c2("def")
 {}

 void MetodoDeClasse(int a, int b, int c)
 {
   int variavelLocal = 10;
 }

 //
 // sem espaço antes ou depois dos parênteses ou chaves
 // e UM espaço depois das vírgulas
 // espaço entre os operadores matemáticos
 // chaves embaixo
 // 
 void OutroMetodoDeClasse(int a, int b, int c)
 {
   int a;
   a = 10;
   a += 5;
   ++a;
   a = b + c;

   for(int x = 0 ; x < 10 ; ++x)
   {
     if(x == 5)
       break;
      // 
      // nada de colocar tudo na mesma linha:
      // if(x == 5)break;
      //
   }

   int i = FuncaoComUmMonteDeParametros(
     "parametro1",
     "parametro2",
     "parametro3",
     "parametro4",
     "parametro5");

   MetodoDeClasse(a, b, c);
 }

 void SetVariavelDeClasse(int i)
 {
   m_variavelDeClasse = i
 }

 //
 // ainda estou pensando em abolir o Get, tipo
 // int variavelDeClasse();
 // mas ainda estou só pensando
 //
 int GetVariavelDeClasse()
 {
   return m_variavelDeClasse;
 }
};

Quando der manutenção em um programa, use o mesmo estilo de nomenclatura. Não importa se o padrão é porco, se você não gosta. É um padrão. Mude o projeto inteiro se tiver tempo para isso, mas não use dois padrões para o mesmo projeto. Isso torna o código mais porco ainda. Eu sei, é difícil de ler, difícil de entender, mas é assim que está feito. Sempre que pegar um código novo para modificar, tente entender qual é o padrão de nomenclatura e siga-o.

Use nomes claros e explicativos para as funções e variáveis. A função ApagaClientePendentes é melhor do que DelCliPen ou del_cliente_p. Os códigos fontes são feitos para seres humanos entenderem, não para que o computador entenda. Quem gera o que o computador entende é o compilador. E não se esqueça: se alguém não gostar dos nomes gigantescos, uma manhã de find/replace resolve o problema.

Não economize nos comentários. Já falei bastante sobre isso. O argumento de que os comentários podem ficar fora de sincronia e complicar mais a sua vida é totalmente furado. É o mesmo que dizer que não vai fazer uma parte do software porque ela pode ter bugs.

Em 27/11/2007 15:48, por Rodrigo Strauss

Comentários