RULES
AND
RECOMMENDATIONS
Style 1.11
The names of parameters to functions should be specified in the function declaration if the type name is insufficient to describe the parameter.
Style 1.12
Always provide an access specifier for base classes and data members.
Style 1.13
The public, protected, and private sections of a class should be declared in that order.
Style 1.14
The keyword
struct
should only be used for a C-style struct.
Style 1.15
Define inline member functions outside the class definition.
Style 1.16
Write unary operators together with their operand.
Style 1.17
Write access operators together with their operands.
Style 1.18
Do not access static members with '
.
' or '
->
'.
The declaration of a function often contains more information than the compiler needs to see. For example, names on formal parameters are only needed in the function definition, not in declarations.
Parameter names are meant to make it easier for a programmer to understand the purpose and usage of a function. It is in general better to supply too many names than too few, but if the type name is sufficient to describe the
purpose of a parameter, the declaration will be shorter and as easy to understand as without the name.
template<class T>
class list
{
public:
list();
explicit list(const T&);
list(const list<T>&);
list<T>& operator=(const list<T>&);
~list();
// member template
template <class InputIterator>
void insert(iterator position,
InputIterator first,
InputIterator last);
void insertFirst(const T&);
void insertLast(const T&);
// ...
};
The purpose of all member functions above is obvious, just by looking at their
names and the
type of the parameters, except for the only member function with two parameters of the same type, the
insert()
member function. To explain the purpose of each
parameter, all its parameters has been given
names.
All members of a class are private unless the class has an access specification. Likewise a base class will be private unless declared otherwise. You should not use this default behavior. It is much better to explicitly show the reader of the code what you mean.
// Base class B implicitly declared private
class A : B // Not recommended
{
// Not recommended:
implicit access specifier
int i;
public:
// ...
};
// Base class B explicitly declared private
class A : private B // Recommended
{
public:
// ...
// Recommended: explicit access specifier
private:
int i;
};
The public part should be most interesting to the user of the class, and should therefore come first. The protected part is of interest to derived classes and should therefore come after the public part, while the private part should be of nobody's interest and should therefore be listed last in the
class declaration.
There is only one major difference between a struct and a class in C++. Everything in a struct is by default
public, which is different from a class where everything by default is
private. This is for
compatibility with C, since everything in a C struct is public. Apart from that there are no big differences. A struct can have member functions and inherit from other classes. It would be possible to only use struct instead of class, but that would make your code more difficult to understand.
To avoid confusion, the keyword
struct
should only be used when you are grouping built-in data types into a C-style struct; a
POD-struct (POD is an acronym for "plain old data"). A struct should therefore have no
member functions, nor data members of class types. In other words, if you group anything in a struct that does not exist in C (
references, c
lass objects etc.) then you should use a class instead.
Inline member functions can be defined inside or outside the class definition. We strongly recommend the second alternative. The class definition will be more compact and comprehensible if no implementation can be seen in the class interface.
class X
{
public:
// Not recommended: function definition in class
bool insideClass() const { return false; }
bool outsideClass() const;
};
// Recommended: function definition outside class
inline bool X::outsideClass() const
{
return true;
}
The various operators should be presented to the reader so that their use is completely clear. Some of them look identical but are very different, like unary and binary
*
. Unary operators such as unary
*
and
++
are best written together with their operand.
int* i = new int(77);
cout << * i << endl; // Not recommended
cout << *i << endl; // Recommended
Access operators, such as
.
and
->
are best written together with both their operands.
a->foo(); // Recommended
b.bar(); // Recommended
Static members are members of the class and not of an object of the class. Accessing such members as if they were object members would therefore be confusing.
class G
{
public:
// ...
static G* create();
// ...
};
G* G::create()
{
return new G;
}
G g;
G* gp = new G;
G* gp1 = g.create(); // Not recommended
G* gp2 = gp->create(); // Not recommended
G* gp3 = G::create(); // Recommended
