My Coding Style I stole from people

GrapeJuiceSoda | Sat May 15 01:28:17 PM PDT 2021

Inspirations:

Comments:


/*
 * Very important single-line comments look like this.
 */


/* single-line comments are all lowercase */


/*
 * Multi-line comments look like this.  Make them real sentences.
 * Fill them so they look like real paragraphs.
 */


/*
 * Avoid obvious comments such as
 * "Exit 0 on success."
 */

Variable Names:

Length is not a virtue in a name; clarity of expression is. (pikestyle)
Counters variables are one letter names
Temporary variables have 'temp_' at the beginning
Local variables are only used in a small scope, so they don't need long names. Long names are annoying both to read and to write.

Local variables


int lowerCamelCase;

Function names


void*
snake_case(int a)
{


}

Pointers


char* snake_case_p /* always add a '_p' at the end */

Struct/Union/Enum


typedef struct 
{
    int a;
    int b;
}UpperCamelCase;


Enum
{
    UPPERCASE,
    UPPERCASE,
}

Variable Declarations

Declare variables at the beginning of blocks, and leave an empty line after the last declaration


int f(void) {
    int a;


    for (a = 0; a < 3; a++) {
        int validInForBlock;


        validInForBlock = a;
    }


    {
       int scopedVariable;


       scopedVariable = 42;
    }
}

Tests and boolean values

Use 'bool' types instead of integers
Always use compound assignment and test unless the line grows too long


if (!(p = malloc(sizeof(*p))))
    hcf();

Structs:

Use don't use typedef when declaring structs
Struct names are always capitalized


typedef struct Foo Foo;


struct Foo
{
    int a;
    int b;
};

Enums:

Use enums for values that are grouped semantically
Do not use define for integer constants. Use enum
Capitalize enum names
The last item in an enum ends with a comma


Enum Direction 
{
	DIRECTION_X = 52,
	DIRECTION_Y = 23,
	DIRECTION_Z = 7,
};

Pointers:

In declaration of pointers the * is adjacent to variable name, not type.


int *int_p;
short *short_p;
Rect *rect_p;
void(*func_p)(int i);

Cast void pointers to char pointers when doing pointer arithmetic


void *target = (char *)s->elems + (s->logicalLen * s->elemSize);

Try to use array syntax instead of pointer arithmetic


int a = int_arr[4];
/* NOT */
int a = *(int_p + 4)

Function prototypes:

Prototypes should not have variable names associated with the types


void function(int);

Functions definitions:


static void
func(void)
{
    puts("....");
}


void*
func(void)
{
    puts("....");
}

Keywords:

Put a space between control flow keywords (if, for, while)


if (usage)
{
    puts("....");
}


while (usage)
{
    puts("....");
}

Print statements

Space before and after
Line starting with '{' also count as a space
If there is a print block surround with {}


int a = 9;


printf("%d\n", a);


{
    printf("Hello ");
    printf("World");
    printf("\n");
}

Return statements

Space before statement


free(random_p);


return 0;

Exiting

Exits should be 0 on success, or non-zero for errors.

Casting

Do not cast anything that returns a void pointer i.e. malloc
When doing pointer arithmetic with void pointers, cast to (char *)

Operators

Put a space before and after binary operators


    int two = 1 + 1;

Don't put spaces after unary operators


    int fd = -1;
    (int)42;

Switch case:

Indent both case labels and statements in switch blocks


    switch (val) 
    {
        case 1:
            break;
        case 2:
            break;
        default:
    }

Sample Code

Some rules I forgot to write down, this is a sample program in my style




typedef struct child Child;
typedef struct parent Parent;


void create_parent(Parent *);
void create_child(Child *);
void free_parent(Parent *);
void free_child(Child *);


struct child
{
	int age;
	char *name;
};


struct parent
{
	Child *child;
	int age;
	char *name;
};


int
main(void)
{
    Parent Mom;
    Parent *parent_p;


    *parent_p = &Mom;
    create_parent(parent_p);
    parent_p->name = strdup("Masayo");
    parent_p->child->name = strdup("Kendall");
    {
	    printf("%d\n", parent_p->age);
	    printf("%s\n", parent_p->name);
	    printf("%s\n", parent_p->child->name);
    }
	free_parent(parent_p);


	return 0;
}


void
create_parent(Parent *parent_p)
{
	if (!(parent_p->child = malloc(sizeof(Child))))
	{
		printf("%s:%d: malloc failed\n", __FILE__, __LINE__);


		exit(1);
	}
	parent_p->age = 0;
}


void
create_child(Child *child_p)
{
	child_p->age = 0;
}


void
free_parent(Parent *parent_p)
{
	free_child(parent_p->child);
	free(parent_p->child);
	free(parent_p->name);
}


void
free_child(Child *child_p)
{
	free(child_p->name);
}

Top