C cheatsheet

0
128

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

Operators

( ) 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 */
break;
case constant_2: /* drop through and do same as constant_3*/
case constant_3:
statement_sequence /* can have but does not need { } */
break;
case constant_4:
statement_sequence /* does this and next */
/* statement_sequence also*/
case constant_5:
statement_sequence
break;
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 */