Most crucial elements in a light-weight C++ coding standard [closed]

Answer 1

Prefer RAII.

STL's auto (and shared in boost & C++0x) pointers may help.

Answer 2

Keep functions to a reasonable size. Personally, I like to keep functions under 25 lines. Readability is enhanced when you can take a function in as a unit rather than having to scan up and down trying to figure out how it works. If you have to scroll to read it, it makes matters even worse.

Answer 3

Probably a no-brainer, but nevertheless an important rule:

Avoid undefined behavior.

There's an awful lot of it in C++, and it's probably impossible to write a nontrivial application that doesn't depend on it somehow, but the general rule should still be "undefined behavior is bad". (Because sadly there are C++ programmers out there who feels that "it works on my machine/compiler" is good enough).

If you have to rely on it, make it clear to everyone what, why, where and how.

Answer 4

Use const identifiers by default. They provide guarantees for the reader/maintainer, and are way easier to build in than to insert afterwards.

Both member variables and methods would be declared const, as well as function arguments. const member variables enforce proper use of the initializer list.

A side-effect of this rule: avoid methods with side-effects.

------ EDIT

const member variables seemed like a good idea; this is not always the case: they effectively make any object immutable. This becomes problematic for e.g. sorting a vector.

struct A {
    const int i;
};

bool operator<(const A& lhs, const A& rhs) {
    return lhs.i < rhs.i;
}

int main() {
    std::vector<A> as;
    as.emplace_back(A{1});
    std::sort(begin(as), end(as));
}

error message:

... note: copy assignment operator of 'A' is implicitly deleted because
field 'i' is of const-qualified type 'const int'
...
in instantiation of function template specialization 'std::sort<...>'
requested here

    std::sort(begin(as), end(as));

Answer 5

Only trivial use of the ? : operator, i.e.

float x = (y > 3) ? 1.0f : -1.0f;

is ok, but this is not:

float x = foo(2 * ((y > 3) ? a : b) - 1);

Answer 6

Curly braces for any control statement. (Thanks to own experience and reinforced by reading Code Complete v2):

// bad example - what the writer wrote
if( i < 0 ) 
    printf( "%d\n", i );
    ++i; // this error is _very_ easy to overlook!  

// good example - what the writer meant
if( i < 0 ) {
    printf( "%d\n", i );
    ++i;
}