mirror of
https://github.com/namibia/awesome-cheatsheets.git
synced 2024-11-18 11:05:16 +00:00
242 lines
8.5 KiB
Plaintext
242 lines
8.5 KiB
Plaintext
|
|
|
|
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 */
|
|
|