C Coding Standards Summary

Do's:

Header files have full function prototypes of global functions. The return type and each function arguments are to be explicitly declared.
Functions and global variables used only within a single modules should have the static qualifier and should either be defined or fully declared before their first use in the mdoule.
Use the new types: void's and enum's wherever possible.
When declaring a global variable in a header file, use an explicit extern.
If you need to write system-dependent code, try to modularize. and isolate it as much as possible (perhaps with):
```
   #if MS_WIN
   ...

   #endif
```
or
```
   #if LINUX
   ...
   #endif
```

For constants, consider using:

enum { Red = 0xF00, Blue = 0x0F0, Green = 0x00F };
static const float pi = 3.14159265358;

instead of #defines, which are rarely visible in debuggers.

Macros should avoid side effects. If possible, mention each argument exactly once (avoiding pre/post increment/decrement problems). Fully parenthesize all arguments.

Don'ts

Do not use Implicit declarations of int
Surprising precedence of operators - use parenthesis
Similarly, don't declare a function with an implicit return type. If it returns an integer value, declare it int. If it returns no value, declare it void.
Do not use old-style function definitions where the args are declared outside the parameter list.

Warnings:

Beware of nested includes, because of make issues. Consider using the makedepend tools to help maintain your source file dependencies in your Makefile.
In struct definitions place larger size fields first to avoid wasted space.
Use goto sparingly. Two harmless places to use it are to break out of a multilevel loop, or to jump to common function exit code. Often these are the same places. There are 6 total conditions or programming forms in which goto is unavoidable.

Naming Conventions

Names should be meaningful in the application domain, not the implementation domain. Note that well-structured code is layered internally, so your implementation domain is also the application domain for lower levels.

Names should be chosen to make sense when your program is read. Thus, all names should be parts of speech which will make sense when used with the language's syntactic keywords. Variables should be noun clauses.

Boolean variables should be named for the meaning of their "true" value. Procedures (functions called for their side-effects) should be named for what they do, not how they do it.

Function names should reflect what they return, and boolean-valued functions of an object should be named for the property their true value implies about the object. Functions are used in expressions, often in things like if's, so they need to read appropriately. For instance,

if (checksize(s))

is unhelpful because we can't deduce whether checksize returns true on error or non-error; instead

if (validsize(s))

makes the point clear and makes a future mistake in using the routine less likely.

Module globals should have a short prefix in names identifying the module, e.g. "wgl_" to avoid name clashes when combining independently developed modules.

Use some consistent scheme for naming related variables. If the top of memory is called physlim, should the bottom be membase? Consider the suffix -max to denote an inclusive limit, and -lim to denote an exclusive limit.

The Standard Library

Some notes on using particular functions:

Never use gets(). Use fgets instead so that you can be sure that you don't overflow your buffer.

Beware of library functions that have state and are called multiple times, especially in a loop. These functions include but are not limited to: strtok() and getchar() (use fgetc() rather than getchar()).