Rule 0 Every time a rule is broken, this must be clearly documented.
Rule 1 Include files in C++ always have the file name extension ".hh".
Rule 2 Implementation files in C++ always have the file name extension ".cc".
Rule 3 Inline definition files always have the file name extension ".icc".
Rule 4 Every file that contains source code must be documented with an introductory comment that provides information on the file name and its contents.
Rule 5 All files must include copyright information.
Rule 6 All comments are to be written in English.
Rule 7 Every include file must contain a mechanism that prevents multiple inclusions of the file.
Rule 8 When the following kinds of definitions are used (in implementation files or in other include files), they must be included as separate include files:
Rule 9 Definitions of classes that are only accessed via pointers (*) or references (&) shall not be included as include files.
Rule 10 Never specify relative UNIX names in #include directives.
Rule 11 Every implementation file is to include the relevant files that contain:
Rule 12 The identifier of every globally visible class, enumeration type, type definition, function, constant, and variable in a class library is to begin with a prefix that is unique for the library.
Rule 13 The names of variables, constants, and functions are to begin with a lowercase letter.
Rule 14 The names of abstract data types, structures, typedefs, and enumerated types are to begin with an uppercase letter.
Rule 15 In names which consist of more than one word, the words are written together and each word that follows the first is begun with an uppercase letter.
Rule 16 Do not use identifiers which begin with one or two underscores (`_' or `__').
Rule 17 A name that begins with an uppercase letter is to appear directly after its prefix.
Rule 18 A name that begins with a lowercase letter is to be separated from its prefix using an underscore (`_').
Rule 19 A name is to be separated from its suffix using an underscore (`_').
Rule 20 The public, protected, and private sections of a class are to be declared in that order (the public section is declared before the protected section which is declared before the private section).
Rule 21 No member functions are to be defined within the class definition.
Rule 22 Never specify public or protected member data in a class.
Rule 23 A member function that does not affect the state of an object (its instance variables) is to be declared const.
Rule 24 If the behaviour of an object is dependent on data outside the object, this data is not to be modified by const member functions.
Rule 25 A class which uses "new" to allocate instances managed by the class, must define a copy constructor.
Rule 26 All classes which are used as base classes and which have virtual functions, must define a virtual destructor.
Rule 27 A class which uses "new" to allocate instances managed by the class, must define an assignment operator.
Rule 28 An assignment operator which performs a destructive action must be protected from performing this action on the object upon which it is operating.
Rule 29 A public member function must never return a non-const reference or pointer to member data.
Rule 30 A public member function must never return a non-const reference or pointer to data outside an object, unless the object shares the data with other objects.
Rule 31 Do not use unspecified function arguments (ellipsis notation).
Rule 32 The names of formal arguments to functions are to be specified and are to be the same both in the function declaration and in the function definition.
Rule 33 Always specify the return type of a function explicitly.
Rule 34 A public function must never return a reference or a pointer to a local variable.
Rule 35 Do not use the preprocessor directive #define to obtain more efficient code; instead, use inline functions.
Rule 36 Constants are to be defined using const or enum; never using #define.
Rule 37 Avoid the use of numeric values in code; use symbolic values instead.
Rule 38 Variables are to be declared with the smallest possible scope.
Rule 39 Each variable is to be declared in a separate declaration statement.
Rule 40 Every variable that is declared is to be given a value before it is used.
Rule 41 If possible, always use initialization instead of assignment.
Rule 42 Do not compare a pointer to NULL or assign NULL to a pointer; use 0 instead.
Rule 43 Never use explicit type conversions (casts).
Rule 44 Do not write code which depends on functions that use implicit type conversions.
Rule 45 Never convert pointers to objects of a derived class to pointers to objects of a virtual base class.
Rule 46 Never convert a const to a non-const.
Rule 47 The code following a case label must always be terminated by a break statement.
Rule 48 A switch statement must always contain a default branch which handles unexpected cases.
Rule 49 Never use goto.
Rule 50 Do not use malloc, realloc or free.
Rule 51 Always provide empty brackets ("[]") for delete when deallocating arrays.
Next section: Summary of Recommendations