Page Comparison

Include guards

#pragma once

#ifndef MODULE_H
#define MODULE_H
...
#endif

Although #pragma once isn't officially part of the C standard, it's widely supported and easier to use than include guards.

Note that include guards are used to prevent double inclusion of headers.

Conditionals and loops

if (cond) {
  ...
} else if (cond) {
  ...
} else {
  ...
}

OR

for (int i = 0; i < x; i++) {
  ...
}

if(cond)
{
}
else
{
}

OR

if (cond)
  func();

OR

if(cond){
  ...
}

Braces are always required, even for single-line statements. They should be on the same line as the conditional.

Adequate spacing should be provided between statements.

In general, please be consistent.

Prefer descriptive, reasonable length variable names.

Note that function and variable names follow the underscore_lowercase naming convention.

Variable names

(static)

static uint8_t s_descriptive_name = 0;

static void prv_func(void) {
  // do stuff
}

A static variable that is global to a file should be prefixed with s_.

You should not have static variables in a function, since your functions should not be maintaining state (unless you have a really good reason).

Function names

(public)

Function names

(private)

Macros

#define MACRO(x) ((x)*2)

Enums

typedef enum {
  ENUM_TYPE_A = 0,
  ENUM_TYPE_B,
  ENUM_TYPE_C,
  NUM_ENUM_TYPES,
} enum_typeEnumType;

enum enum_type {
  a,
  b,
  c,
};

Typedef enums because we generally use them to group bitmasks, and it would get messy quickly.

Declare them in ALL_CAPS prefixed with the enum name.

The final entry in any enum should be NUM_ENUM_TYPES. Note the plurality of the type and the prefix NUM. This allows for the writing of nice guard clauses.

typedef struct Foo {
  ...
} Foo;

struct Foo {
  ...
};

Use UpperCamelCase for struct definitions.

Typedef'd structs make it easier to think about them as objects, and provide some abstraction.

The original struct should still be named to allow for forward declarations.

GPIOAddress address = { 1, 0 };
int a[] = { 0, 1, 2, 3 };

// GNU Style
GPIOAddress addresses[] = {
  [GPIO_PIN1] = { .port = 1, .pin = 1 }, //
  [GPIO_PIN2] = { .port = 1, .pin = 2 }, //
};

GPIOAddress address = {1, 0};
int a[] = {0, 1, 2, 3};

Structs and arrays should have 1 space between each brace and the first/last elements.

GNU Style initializers are encouraged as they are more explicit and ensure consistency in the result of changes in definitions of structs/enums.

The trailing // is used to help clang-format align the elements as a single column as opposed to bin-packing.

As of August 2017 there is a bug in clang-format so that

{.port = 1, .pin = 1 } is the result of formatting this has been fixed upstream and should be resolved in the next release.

Make use of bitwise operations whenever working with bitmasks.

Use macro or enums to define bitmasks.

Try to keep the order of operations from MSB to LSB.

// This is a well-formatted comment.

int8_t a = 0;  // This is also ok.

Use the // syntax for comments.

Comments can also be trailing to a line

int *pointer = NULL;
void func(int *x, int *y);

int* pointer = NULL;
int * x = NULL;
int *x, y;
void func(int * x, int* y);

The asterisk should always be adjacent to the variable.

Do not declare multiple variables in the same declaration if any are pointers.