Ellemtel C++ Style and Rules - Assigning Names

The Unix command ar truncates file names that are longer than 15 characters.

Cfront normally modifies generated C-identifiers that are longer than 31 characters by truncating them and adding a hash value that is generated from the truncated part of the string.

The use of two underscores ('__') in identifiers is reserved for the compiler's internal use according to the ANSI-C standard.

Underscores ('_') are often used in names of library functions (such as "_main" and "_exit"). In order to avoid collisions, do not begin an identifier with an underscore.

One rule of thumb is that a name which cannot be pronounced is a bad name. A long name is normally better than a short, cryptic name, but the truncation problem must be taken into consideration. Abbreviations can always be misunderstood. Global variables, functions and constants ought to have long enough names to avoid name conflicts, but not too long.

Classes should be named so that "object.function" is easy to read and appears to be logical.

There are many class libraries available for purchase and there may be tens of thousands of classes in a large project!! Because of this, it is important to be careful that name collisions do not occur. One way of preventing collisions is to have strict rules for assigning names to globally visible objects (such as our use of a prefix). In this way, classes from several different class libraries may be used at the same time.

Names for the following types of objects are to be prefixed:

• Type names (classes, typedefs, enums, structs, unions, etc.)
• Global variables and constants
• Function names (not member functions names)
• Preprocessor macros (#define)

The use of prefixes can sometimes be avoided by using a class to limit the scope of the name. Static variables in a class should be used instead of global variables and constants, enumerated data types, and typedefs. Although nested classes may be used in C++, these give rise to too many questions (in connection with the language definition) to be able to recommend their use.

Exception to Rule 12

No exceptions.

Exception to Rule 13

No exceptions. (At times, an identifier begins with an abbreviation written in uppercase letters, to emphasize the way in which the name is used. Such an abbreviation is considered to be a prefix).

Exception to Rule 14

If the last letter in a word is in uppercase, an underscore is to be used as a word separator.

Exception to Rule 15

No exceptions.

Exception to Rule 16

No exceptions.

Exception to Rule 17

No exceptions.

Exception to Rule 18

No exceptions.

Exception to Rule 19

No exceptions.

   const char* functionTitle = "EUA_Special";
   int currentIO_Stream = 1; // Last Character in currentIO is in uppercase!

   int groupID;                    // instead of grpID
   int nameLength;                 // instead of namLn
   PrinterStatus resetPrinter;     // instead of rstprt

   void termProcess();             // Terminate process or
                                   // terminal process?

   int I0 = 13;                    // Names with digits can be
   int IO = I0;                    // difficult to read.

   class Emc2Class
   {
      public:
         Emc2Class();    // Default constructor
         // ...
      private:
         int id;
         // ...
   };

   // 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;