Context Navigation

Changes between Version 43 and Version 44 of ResumedC

Timestamp:: Sep 9, 2009, 7:13:21 PM (15 years ago)
Author:: Thanatermesis
Comment:: --

Legend:

: Unmodified
: Added
: Removed
: Modified

ResumedC

-              v43
+              v44
 === Comments ===
+== Comments ==
 The comments are very important for yourself. Basically, you need to comment all your functions and declarations and especially your variables in order to know *what* exactly they are and to remember the special things about these variables.
 …
 === Variables ===
+== Variables and Data types ==
 Variables inside functions (or main) are not ''heritable'' between functions, if you want to call a function with a variable you can use the ''arguments'' on the function call (or a pointer for argument)
 If you need a ''Global variable''' in your entire code, you need to declare them out of any function
+If you need a ''Global variable'' in your entire code, you need to declare them out of any function
 Every time you enclose a variable declaration inside a block '''{}''', it is limited to this section (will not work outside of it). If you have variables declared out of any function and/or out of main(), it is supported by all the entire application. Also, if you declare a variable inside a block that is already declared outside of it, then for inside the block it is used only the new declared one, not the one declared out of it, however, this practice is not good since may be very confusing.
 …
 '''signed''': means ''with sign'', so, values negative and positive, for example if the '''char''' variable has a limit of 255 values, using the '''sign''' mode we can use from '''-128''' (negative) to '''127''' (positive), and using '''unsigned''' we can use from '''0''' to '''255'''
 ==== Extern ====
+=== Extern ===
 Since it is the default value out of any function (global mode), you should ignore it. You can use it too for say that a variable is declared from a different (outside) file
 ==== Static ====
+=== Static ===
 You can use ''static'' inside a function or outside it, it has two different meanings:
  * Inside a function: You can ''pre'' set a value to a variable ''(static int foo = 5)'', then the first time you enter on the function it will be set to 5, but the next times it not set again, it just remember the last value used
 …
 ==== Void ====
+=== Void ===
  * In a function declaration means that the function returns no value
  * When used in a pointer declaration (called ''pointer to void''), void defines a generic pointer, so it returns an address, it is commonly used when a function is called with differents types of data, specially pointers of types differents, and also very used on these ways:
 …
+==== Conversion ====
+You can convert a variable type to other at any time by:
+{{{
+#!C
+int value = 5;
+printf ("%f", (float)value );
+}}}
+=== Functions ===
+A function can be (re)called too (inside himself), this is known as ''recursion''
+==== Basic example ====
+{{{
+#!C
+float triangle (float width, float height)
+ ...
+}}}
+ This function means: it needs to return a ''float'' variable, it is called with two parameters of type float too, this function can't modify directly the variables (width or height), for that is needed to use pointers (because we have the address (of memory) to that data instead the data value, so we can modify its content (data))
+==== Structure of a function ====
+{{{
+#!C
+[class_of_memorization] [type] name( [arguments] )
+// class: It will be static or extern (see Variables section)
+// type: It will be anything (void, int, char, a pointer...), except an array
+// arguments: Arguments to pass to a function, if any
+}}}
+==== Modification of variables by pointers ====
+This is a example of a function call and modification by using pointers:
+{{{
+#!C
+void convert_to_42 ( int *input )
+{
+   *input = 42;
+}
+int value = 12;
+convert_to_42 ( &value );
+}}}
+==== Prototype of Functions ====
+When there's no arguments for the function, just put a ''void'' itself inside the (), so for the content of arguments.
+When there's arguments, you should add too a name of variable after it, the mean of this is just to be more easy to understand when reading the headers file for example
+{{{
+#!C
+double calc( double base, double exponent);
+}}}
+=== Constants ===
+The '''constant''' variables are constants, so they can't change, by convention they are in upper-case. You should use it where ever possible, it improves the robustness of the program, better readability, and also improves (just a bit) the optimization, it is a kind of ''rule'' and correct programming. When you are sure that a variable doesn't (or don't want to) change in a scope of the program, you can use it.
+{{{
+#!C
+/* The variable answer_p is a constant and can't change, but the pointer address can be changed. */
+const char *answer_p = "Forty-Two";
+/* If we want to have the inverse to this, we need to put the const AFTER the *, so: */
+char *const answer_p = "Forty-Two";
+   /* Now the pointer can't change the address value, but the data (Forty-Two) can be changed */
+/* Finally, we can set both in constant with something like: */
+const char *const answer_p = "Forty-Two";
+}}}
+=== Volatile ===
+With '''volatile''' you can declare something that will be modified by an external program, on the same way, if you declare ''const volatile foo'', the variable ''foo'' its a constant that cannot be modified by the program itself, but can be modified by an external program
+=== Restrict ===
+It is used for pointers, it is used for optimization, using '''restrict''' on a pointer you are only allowed to access to the object with this pointer
+=== Typedef ===
+With typedef we can define our own variable types, for example:
+{{{
+#!C
+typedef static long int mylongintstatic;
+/* example of declare a variable of this new type: */
+mylongintstatic var1 = 5;
+}}}
+Note that ''typedef'' could be considered similar to the #define statement, but can define more complex objects like:
+{{{
+#!C
+/* group is a type of 10-elements array */
+typedef int group[10]
+}}}
 …
 The ''counters'' of the arrays start by 0, so if you need to create an array of 4 elements you need to declare 4 and use them from 0 to 3, this may sound strange:
  * This maybe sound strange, like ''why i need to declare 4 then instead of 3 ?'': simple, because you are declaring 4, and you still having 4 (0 to 3 = 4)
-=== Constants ===
-The '''constant''' variables are constants, so they can't change, by convention they are in upper-case. You should use it where ever possible, it improves the robustness of the program, better readability, and also improves (just a bit) the optimization, it is a kind of ''rule'' and correct programming. When you are sure that a variable doesn't (or don't want to) change in a scope of the program, you can use it.
-{{{
-#!C
-/* The variable answer_p is a constant and can't change, but the pointer address can be changed. */
-const char *answer_p = "Forty-Two";
-/* If we want to have the inverse to this, we need to put the const AFTER the *, so: */
-char *const answer_p = "Forty-Two";
-   /* Now the pointer can't change the address value, but the data (Forty-Two) can be changed */
-/* Finally, we can set both in constant with something like: */
-const char *const answer_p = "Forty-Two";
-}}}
-=== Relational Operators ===
-{{{
-#!C
-number = 5;
-result = number++; /* first is evaluated the expression, after is incremented, result is 5 */
-number = 5;
-result = ++number; /* first is incremented, after is evaluated the expression, result is 6 */
-total += 2;
-   /* is like */
-   total = total + 2;
-/* There is also: */
-   -=, *=, /=, %=
-}}}
 …
 }}}
 ==== Packaged structures ====
 Image an application that stupidly takes a lot of storage but very few 'cpu' usage and you will need to optimize it for data, imagine that it has 3 variables, ''seen'' is used to know if the element is seen, and ''list'' is used to know if the element is on the list, and ''number'' is the number of the element (the ''data''). Between ''number'' needs to be a full ''int'' that requires 16 bits (or a little less than it), you can set ''seen'' and ''list'' to use only 1 bit each one, and ''number'' to use 14 instead of 16, on that way, you will have the full size of the structure 3 times smaller than originally
+Imagine an application that stupidly takes a lot of storage but very few 'cpu' usage and you will need to optimize it for data, imagine that it has 3 variables, ''seen'' is used to know if the element is seen, and ''list'' is used to know if the element is on the list, and ''number'' is the number of the element (the ''data''). Between ''number'' needs to be a full ''int'' that requires 16 bits (or a little less than it), you can set ''seen'' and ''list'' to use only 1 bit each one, and ''number'' to use 14 instead of 16, on that way, you will have the full size of the structure 3 times smaller than originally
 Normal structure, total: '''48''' bits
 …
 === Pointers ===
 …
  a[i] , *(a+i) , *(pa+i) ,   pa[i]     // In the same method way, the 'i' element of an array (no-pointer)
 }}}
 ==== Double pointers ====
 …
+==== Operators to access to memory ====
+=== Conversion ===
+You can convert a variable type to other at any time by:
+{{{
+#!C
+int value = 5;
+printf ("%f", (float)value );
+}}}
+== Functions ==
+A function can be (re)called too (inside himself), this is known as ''recursion''
+Basic example:
+{{{
+#!C
+float triangle (float width, float height)
+ ...
+}}}
+ This function means: it needs to return a ''float'' variable, it is called with two parameters of type float too, this function can't modify directly the variables (width or height), for that is needed to use pointers (because we have the address (of memory) to that data instead the data value, so we can modify its content (data))
+=== Structure of a function ===
+{{{
+#!C
+[class_of_memorization] [type] name( [arguments] )
+// class: It will be static or extern (see Variables section)
+// type: It will be anything (void, int, char, a pointer...), except an array
+// arguments: Arguments to pass to a function, if any
+}}}
+=== Modification of variables by pointers ===
+This is a example of a function call and modification by using pointers:
+{{{
+#!C
+void convert_to_42 ( int *input )
+{
+   *input = 42;
+}
+int value = 12;
+convert_to_42 ( &value );
+}}}
+=== Prototype of Functions ===
+When there's no arguments for the function, just put a ''void'' itself inside the (), so for the content of arguments.
+When there's arguments, you should add too a name of variable after it, the mean of this is just to be more easy to understand when reading the headers file for example
+{{{
+#!C
+double calc( double base, double exponent);
+}}}
+== Operators ==
+=== Relational Operators ===
+{{{
+#!C
+number = 5;
+result = number++; /* first is evaluated the expression, after is incremented, result is 5 */
+number = 5;
+result = ++number; /* first is incremented, after is evaluated the expression, result is 6 */
+total += 2;
+   /* is like */
+   total = total + 2;
+/* There is also: */
+   -=, *=, /=, %=
+}}}
+=== The , Operator ===
+It can be used specially to include multiple operators, like in a for statement:
+{{{
+#!C
+for (two = 0, three = 0 ; two < 10 ; two +=2, three += 3)
+}}}
+=== Operators to access to memory ===
 || '''Operator''' || '''Description''' || '''Example''' || '''Result''' ||
 …
+=== Typedef ===
+With typedef we can define our own variable types, for example:
+{{{
+#!C
+typedef static long int mylongintstatic;
+/* example of declare a variable of this new type: */
+mylongintstatic var1 = 5;
+}}}
+Note that ''typedef'' could be considered similar to the #define statement, but can define more complex objects like:
+{{{
+#!C
+/* group is a type of 10-elements array */
+typedef int group[10]
+}}}
+=== Misc ===
+== Misc ==
 The '''header''' files should be limited to have only types and definitions.
 …
+==== The , Operator ====
+It can be used specially to include multiple operators, like in a for statement:
+{{{
+#!C
+for (two = 0, three = 0 ; two < 10 ; two +=2, three += 3)
+}}}
+==== The ?: Construct ====
+=== The ?: Construct ===
 It can be used like a replacement of ''if, else...'' but also specially to set values, like:
 {{{
 …
 === Optimizations ===
+== Optimizations ==
 An array do increments of the array level in order to search/find something, by using pointers is a lot faster than generate an index operation, for example:
 …
 ==== How to Optimize ====
+=== How to Optimize ===
  * Loop Ordering: Nested loops should be ordered with the simplest loop outermost and the most complex loops innermost
  * Powers of 2: Use a power of 2 when doing integer multiply or divide. Most compilers substitute a shift for the operation.
 …
 === Compiler ===
+== Compiler ==
 If you want to see the preprocessor messages (values), you can see them when compiling by using the -E option (in gcc)
 …
 === Debugging ===
 ==== GDB ====
+== Debugging ==
+=== GDB ===
 Basic Commands
 …
 ==== Messages ====
+=== Messages ===
  * Segfault: The program has tried to dereference a pointer containing a bad value
  * Stack Overflow: The program has tried to use too many temporary variables. Common problem when there's a infinite loop recursiontes ==