Skip to main content

An awesome C language cheatsheet.

main() Function

* The main() function is the starting point of the program:     int main (int argc, char *argv[])
* The return type of the main() function is an integer (type int) and it is known as the return value of the program.
* As a rule of thumb, value 0 means success while non-zero means an error conditions.

Include Files

* The purpose of these files is to tell the compiler about the existence of external functions which the source code will make use of.

Preprocessor directives:
  #include "mine.h" search current working directory first
  #include <stdio.h>    search command line directory then system
  #define TRUE 1    macro substitution, usually use capitals
  #define min(a,b) (a<b)?(a):(b)    macro substitution with parameters
  #define abs(a) (a<0)?(-(a)):(a)   macro substitution
  #define note /* comment */    this comment gets inserted every time note appears */
  backslash \ at end of a line means continue
  #undef TRUE   undefines a previously defined macroname
  #error    stop compiling at this point
  #if expression    conditional compilation, start if structure
  #elif expression  else if expression != 0 compile following code
  #else else compile following code
  #endif    end of conditional compiling
  #ifdef macroname  like #if, compiles if macroname defined
  #ifndef   like #if, compiles if macroname undefined
  #line number [filename]   set origin for __LINE__ and __FILE__
  #pragma   gives the compiler commands

Create and execute a program

In Linux systems:
    1. Open up a terminal
    2. Create the program: nano nameProgram.c
    3. Write the program and save it
    4. gcc -o nameExecutable nameProgram.c

32 Reserved words

Term        Description
auto        optional local declaration
break     used to exit loop and used to exit switch
case        choice in a switch
char         basic declaration of a type character
const        prefix declaration meaning variable can not be changed
continuego to bottom of loop in for, while and do loops
default    optional last case of a switch
do         executable statement, do-while loop
double     basic declaration double precision floating point
else        executable statement, part of "if" structure
enum        basic declaration of enumeration type
extern    prefix declaration meaning variable is defined externally
float       basic declaration of floating point
for       executable statement, for loop
goto        jump within function to a label
if        executable statement
int       basic declaration of integer
long        prefix declaration applying to many types
register    prefix declaration meaning keep variable in register
return    executable statement with or without a value
short       prefix declaration applying to many types
signed    prefix declaration applying to some types
sizeof    operator applying to variables and types, gives size in bytes
static    prefix declaration to make local variable static
struct    declaration of a structure, like a record
switch    executable statement for cases
typedef   creates a new type name for an existing type
union       declaration of variables that are in the same memory locations
unsigned    prefix declaration applying to some types
void        declaration of a typeless variable
volatile    prefix declaration meaning the variable can be changed at any time
while       executable statement, while loop or do-while loop

Basic types

Type        Description
char        character type, usually one byte ( a string is array of char )
int       integer type, usually 2 or 4 bytes ( default )
float       floating point type, usually 4 bytes
double    floating point type, usually 8 bytes
void        no type, typeless
enum        enumeration type ( user defines the type name )

Type modifiers, prefix for basic types

Modifiers     Description
signed      has a sign ( default )
unsigned      no sign bit in variable
long          longer version of type (short or long alone means short int or
short         shorter version of type long int because int is the default)
const          variable can not be stored into

Storage Types

Prefix     Description
auto         local variable ( default )
static     permanent when function exits, not auto
volatile   can change from outside influence
extern     variables are defined elsewhere, externally
register   assign variable to register


  ( )     grouping parenthesis, function call
  [ ]     array indexing, also  [ ][ ]  etc.
  ->    selector, structure pointer
  .     select structure element
  !     relational not, complement, ! a  yields true or false
  ~     bitwise not, ones complement, ~ a
  ++    increment, pre or post to a variable
  --    decrement, pre or post to a variable
  -     unary minus, - a
  +     unary plus,  + a
  *     indirect, the value of a pointer,  * p is value at pointer p address
  &     the memory address, & b is the memory address of variable b
  sizeof size in bytes,   sizeof a     or  sizeof (int)
    (type) a cast, explicit type conversion,  (float) i, (*fun)(a,b), (int*)x
  *     multiply, a * b
  /     divide, a / b
  %     modulo, a % b
  +     add, a + b
  -     subtract, a - b
  <<    shift left,  left operand is shifted left by right operand bits
  >>    shift right, left operand is shifted right by right operand bits
  <     less than, result is true or false,  a %lt; b
  <=    less than or equal, result is true or false,  a <= b
  >     greater than, result is true or false,  a > b
  >=    greater than or equal, result is true or false, a >= b
  ==    equal, result is true or false,  a == b
  !=    not equal, result is true or false,  a != b
  &     bitwise and,  a & b
  ^     bitwise exclusive or,  a ^ b
  |     bitwise or,  a | b
  &&    relational and, result is true or false,  a < b && c >= d
  ||      relational or, result is true or false,  a < b || c >= d
  ?     exp1 ? exp2 : exp3  result is exp2 if exp1 != 0, else result is exp3
  =     store
  +=    add and store
  -=    subtract and store
  *=    multiply and store
  /=    divide and store
  %=      modulo and store
  <<=   shift left and store
  >>=   shift right and store
  &=    bitwise and and store
  ^=    bitwise exclusive or and store
  |=    bitwise or and store
  ,     separator as in   ( y=x,z=++x )

Operator precedence

More precedence

LR  ( ) [ ] -> . x++ x--
RL  ! ~ - + ++x --x * & sizeof (type)
LR  * / %
LR  + -
LR  << >>
LR  < <= > >=
LR  == !=
LR  &
LR  ^
LR  |
LR  &&
LR  ||
RL  ? :
RL  = += -= *= /= %= >>= <<= &= ^= |=
LR  ,

Less precedence

Conditional branching

 if ( condition ) statement ;
  else statement_2 ;            /* optional  else  clause */

Switch statement

switch ( expression )      /* constants must be unique              */
      case constant_1:       /* do nothing for this case              */
      case constant_2:       /* drop through and do same as constant_3*/
      case constant_3:
         statement_sequence  /* can have but does not need  { }       */
      case constant_4:
         statement_sequence  /* does this and next */
                                     /* statement_sequence also*/
      case constant_5:
      default:               /* default executes if no constant equals*/
         statement_sequence  /* the expression. This is optional      */

Function definition

type function_name(int a, float b, const char * ch,...) { function_body }

/* only parameters passed by address can are modified*/

/* in the calling function, local copy can be modified*/

char * strcpy( char * s1, const char * s2 ) { statements }

Declarations forms

basic_type variable;

type variable[val][val]...[val]={data,data,...};  /*multidimensional array*/

struct struct_name {     /* struct_name is optional */
     type variable_1;    /* any declaration */
     ...                   /* all variable names must be unique*/
} variable_1, ... ;      /* variables are optional */

struct struct_name {          /* struct_name is optional */
     type variable_1: length; /* any declaration : length in bits */
         ...                            /* type is int, unsigned or signed */
} variable_1, ... ;           /* variables are optional, they can also be arrays and pointers */

union union_name {            /* union_name is optional */
    type variable_1;          /* variable_1 overlays variable_2 */
    type variable_2;
} variable_a, ...;            /* variables are optional */

enum enum_type                /* enum_name is optional */
  { enumeration_name_1,       /* establishes enumeration literals */
    enumeration_name_2=number,/* optional number, */
      ...                     /* default is 0, 1, 2, ... */
  } variable, ...;            /* variables are optional */

 /* use dot notation to select a component of a struct or union */