From 164c13f813529c0462b07db4aab31c5d5d91dcd6 Mon Sep 17 00:00:00 2001
From: raulvillora <raulwalencia@gmail.com>
Date: Wed, 14 Mar 2018 15:39:28 +0100
Subject: [PATCH] Create C.txt

Brief summary of C
---
 languages/C.txt | 241 ++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 241 insertions(+)
 create mode 100644 languages/C.txt

diff --git a/languages/C.txt b/languages/C.txt
new file mode 100644
index 0000000..5ed3de5
--- /dev/null
+++ b/languages/C.txt
@@ -0,0 +1,241 @@
+
+
+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 */
+