Regras e recomendações
5 - Nomes
Regras
  • 12: O identificador de todas as classes visíveis globalmente, de dados do tipo enum, de definição de tipos, de funções, de constantes e de variáveis em uma biblioteca de classes, começam com um prefixo que seja único em todo o contexto da biblioteca.
  • 13: Os nomes de variáveis, constantes e funções começam com um letra minúsucula.
  • 14: Os nome de tipos de dados abstratos, struct, typedef e tipos enum começam com uma letra maiúscula.
  • 15: Em nomes compostos por mais de uma palavra, todas as palavras são escritas em um único bloco, e cada uma das palavras, a partir da segunda palavra, começa com uma letra maiúscula.
  • 16: Não use identificadores que comecem com um ou dois caracteres underscore ( _ ou __ )
  • 17: Um nome que comece com uma letra maiúscula aparece imediatamente após seu prefixo.
  • 18: Um nome que comece com uma letra minúscula é separado de seu prefixo por um caracter underscore ( _ )
  • 19: Um nome é separado de seu sufixo usando-se um caracter underscore ( _ )
Recomendações
  • 14: Não use nomes cuja única diferença seja a grafia em letras minúsculas e maiúsculas.
  • 15: Os nomes não devem conter abreviaturas que não sejam de uso consagrado.
  • 16: Uma variável com um escopo amplo deve ter um nome longo.
  • 17: Escolha nomes para variáveis que implicitamente já sugiram sua utilização.
  • 18: Escreva o código de maneira a facilitar a eventual alteração do prefixo de identificadores globais.
  • 19: Encapsule variáveis globais e constantes, tipos enum e typedef em uma classe.
Nesse capítulo torna-se necessário distinguir entre identificadores e nomes. O nome é aquela parte do identificador que revela seu significado. Um identificador consiste de um prefixo, um nome e um sufixo, nesta ordem. O prefixo e o sufixo são opcionais. O sufixo é usado apenas pelas ferramentas que geram código C++, para evitar colisão com nomes definidos pelo usuário, por isso não se faz maiores referências a sufixo neste documento.

É recomendável que os identificadores não sejam extremamente longos, para evitar o risco de colisão de nomes quando se usa ferramentas que truncam identificadores longos. O UNIX trunca nomes de arquivos maiores que 15 caracteres. Cfront normalmente trunca identificadores maiores que 31 caracteres.

O uso de dois caracteres underscore ( __ ) em identificadores é reservado para uso interno dos compiladores, de acordo com o padrão ANSI-C.

O caracter underscore é normalmente usado em nomes de bibliotecas de funções, tais como _main e _exit. Para evitar colisão, não use nomes de identificadores começando com caracter underscore.

Uma boa regra empírica a considerar é a de que um nome que não pode ser pronunciado não é um bom nome. Um nome longo é melhor que um nome curto, criptografado, mas os problemas relativos a truncagem de nomes muito longos devem ser considerados.

Abreviaturas muitas vezes são mal compreendidas. Variáveis globais, funções e constantes devem ser nomes longos o suficiente para evitar conflitos, mas não tão longos.

Classes devem ser denominadas como objeto.função, que são nomes fáceis de se ler e logicamente compreensíveis. Há várias bibliotecas de classe disponíveis para compra no mercado de software, e pode-se ter dezenas de milhares de classes em um projeto grande. Devido a isso, é importante ser criterioso na definição de nomes para que não ocorram colisões. Uma maneira de prevenir colisões é ter regras específicas para definição de nomes para classes que são visíveis globalmente, utilizando-se de prefixos. Dessa forma diferentes bibliotecas de classes podem ser utilizadas ao mesmo tempo.

Nomes para os seguintes tipos de objetos devem ser prefixados:

  • Nomes de tipos (classes, typedef, enum, struct, unions, etc.)
  • Variáveis globais e constantes
  • Nomes de funções, mas não nomes de funções-membro
  • Macros para o preprocessador (#define)

O  uso de prefixos pode algumas vezes ser evitado usando-se uma classe para limitar o escopo do nome.
Exceções à regra
  • 12: Sem exceções.
  • 13: Sem exceções. Por vezes, um identificador começa com uma abreviatura escrita em letras maiúsculas para enfatizar o modo como é usado. Tal abreviatura é considerada, ou confundida com, um prefixo.
  • 14: Sem exceções. Se a última letra de uma palavra é escrita em letra maiúscula, então um underscore é utilizado como um separador de palavras.
  • 15: Sem exceções.
  • 16: Sem exceções.
  • 17: Sem exceções.
  • 18: Sem exceções.
  • 19: Sem exceções.
Exemplo 9: Exceção quando usando nomes compostos. 
  const char* functionTitle = "EUA_Special";
  int currentIO_Stream = 1; // Last Character in currentIO is in uppercase!
Exemplo 10: Escolha de nomes 
  int groupID;      // instead of grpID
  int nameLength;     // instead of namLn
  PrinterStatus resetPrinter;  // instead of rstprt
Exemplo 11: Nomes ambíguos 
  void termProcess();    // Terminate process or 
          // terminal process?
Exemplo 12: Nomes contendo caracteres numéricos podem causar erros difíceis de se localizar. 
  int I0 = 13;      // Names with digits can be
  int IO = I0;      // difficult to read.
Exemplo 13: Definição de uma classe na biblioteca de classes Emc2. 
  class Emc2Class
  {
    public:
      Emc2Class();  // Default constructor
      // ...
    private:
      int id;
      // ...
  };
Exemplo 14: Um modo de evitar classes e funções globais. 
  // Instead of declaring:
  void Emc2_myFunc1();
  void Emc2_myFunc2();
  class Emc2MyClass { /* ... */ };
        
  // Encapsulate the functions using an abstract class:
  class Emc2
  {
    public:
      static void myFunc1();
      static void myFunc2();
      class MyClass { /* ... */ };
    private:
      virtual dummy() = 0;     // Trick to make the class abstract
  };
        
  // Now, functions and classes may be accessed by using the scope-operator:
  Emc2::myFunc1();
  Emc2::myFunc2();
  Emc2::MyClass myObject; 
Topo Índice
| Home | Bookmarks | Universidades | Para Saber mais | Universidades | WEB Directory | Mapa do site |