Summary of Rules

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:

* classes that are used as base classes,

* classes that are used as member variables,

* classes that appear as return types or as argument types in function/member function prototypes.

* function prototypes for functions/member functions used in inline memberfunctions that are defined in the file.

Rule 9

Definitions of classes that are only accessed via pointers (*) or references (&) shallnot 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:

* declarations of types and functions used in the functions that are implemented in the file.

* declarations of variables and member functions used in the functions that are implemented in the file.

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,1 must define a copy constructor.

Rule 26

All classes which are used as base classes and which have virtualfunctions, must define a virtualdestructor.

Rule 27

A class which uses "new" to allocate instances managed by the class,1 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.