Button

Author: methylDragon

C++/01 C++ - Introduction.md

@@ -156,7 +156,7 @@ Let's make a constant variable of type double (which means it's a decimal number
 
 Also, constants are usually declared with all caps
 
-!! Note, when you declare variables outside of a function, they're **GLOBAL** they can be read by all functions. But if they're declared WITHIN a fucntion, they're **LOCAL** and can only be read by the function in question.
+!! Note, when you declare variables outside of a function, they're **GLOBAL** they can be read by all functions. But if they're declared WITHIN a function, they're **LOCAL** and can only be read by the function in question.
 
 **Other variable data types you have are**
 `char` (Stores a single character, a single byte)
@@ -169,7 +169,7 @@ Also, constants are usually declared with all caps
 `unsigned int` (Same size as signed version)
 `long double` (Not less than double)
 
-Example Declaration:
+**Example Variable Initialisation:**
 
 ```c++
 bool isTrue = true;
@@ -180,6 +180,55 @@ char myChar = 'a';
 // Double quotes " declare strings (a null terminated array)
 // So, if you did char myChar = "a"; It will throw an error! As what you're really saying is
 // char myChar = {'a','\0'}; Which is too big for the array
+
+// You can also initialise multiple variables OF THE SAME TYPE on the same line
+int x = 6, y = 2;
+```
+
+
+
+#### **Multiple ways to initialise a variable**
+
+But it actually turns out that there are three ways to initialise a variable!
+
+You **generally** (not always!) want to prioritise the way you initialise variables in this order, because as we go down, memory use becomes less efficient (assignment creates takes up more space in memory since memory is allocated to the variable (which will be empty) in addition to the data.)
+
+- Brace initialisation (Supported from C++11 onwards) (aka uniform initialisation)
+- Direct initialisation (Almost as good as brace, but not supported for some types)
+- Copy Initialisation (Assignment) (Bad for memory, and also not supported for some types)
+
+**Brace Initialisation**
+
+Read more: https://mbevin.wordpress.com/2012/11/16/uniform-initialization/
+
+```c++
+int variable{5}; // Now stores 5
+int empty_variable{}; // Empty
+
+int error_variable{4.5}; // Brace initialisation disallows 'narrowing' type conversions
+// You'll get an error!
+
+
+int array_var[] {1, 2, 3, 4, 5}; // Oh look an array!
+std::vector<int> vector_var {1, 2, 3, 4, 5}; // Oh my a vector! (Read about vectors later)
+std::set<int> set_var {1, 2, 3, 4, 5}; // Check Python tutorial for set
+std::map<int, std::string> map_var { {0, "zero"}, {1, "one"}, {2, "two"} }; // A 'DICT'!
+```
+
+**Direct Initialisation**
+
+```c++
+int variable(525); // Now stores 5
+
+// Note: variable() will not work! You can't initialise an empty variable that way
+```
+
+**Copy Initialisation** (Lowest priority, try to avoid)
+
+```c++
+// We've seen this before
+
+int a = 5; // Woo
 ```
 
 
@@ -844,3 +893,9 @@ int b = a; // Error: name 'a' is not in scope
                          .  |\-^-/|  .    
                         /| } O.=.O { |\     
 ```
+
+​    
+
+------
+
+ [![Yeah! Buy the DRAGON a COFFEE!](E:/coding-notes/_assets/COFFEE%20BUTTON%20%E3%83%BE(%C2%B0%E2%88%87%C2%B0%5E).png)](https://www.buymeacoffee.com/methylDragon)

C++/02 C++ - Functions and File IO.md

@@ -78,6 +78,90 @@ addNumbers(1, 2); // It'll return 3
 
 
 
+#### **Returning arrays**
+
+Read more + code source: https://www.geeksforgeeks.org/return-local-array-c-function/
+
+Turns out you **can't return arrays** from functions just like that. It's not so simple.
+
+This is a little pre-mature since we have to go into OOP and/or pointers to do it.. but.. Here are the several ways to "return an array" from a function.
+
+**Return a dynamically allocated array pointer**
+
+Like so: `int *arr = new int[100];`
+
+```c++
+int *fun()
+{
+   int *arr = new int[100]; // HERE IT IS!
+
+   arr[0] = 10;
+   arr[1] = 20;
+    
+   return arr; // Return the pointer to the array!
+}
+ 
+int main()
+{
+    int *ptr = fun();
+    cout << ptr[0] << " " << ptr[1]; // Prints 10 20
+    return 0;
+}
+```
+
+**Return a static array**
+
+Like so: `static int arr[100];`
+
+```c++
+int *fun()
+{
+   static int arr[100] // HERE IT IS!
+
+   arr[0] = 10;
+   arr[1] = 20;
+    
+   return arr; // Return the pointer to the array!
+}
+ 
+int main()
+{
+    int *ptr = fun();
+    cout << ptr[0] << " " << ptr[1]; // Prints 10 20
+    return 0;
+}
+```
+
+**Use Structs** (Probably my preferred method)
+
+```c++
+struct arrWrap
+{
+   int arr[100];
+};
+ 
+struct arrWrap fun() // Function returns the struct
+{
+   struct arrWrap x;
+ 
+   x.arr[0] = 10;
+   x.arr[1] = 20;
+    
+   return x;
+}
+ 
+int main()
+{
+   struct arrWrap x = fun();
+   cout << x.arr[0] << " " << x.arr[1]; // And you can access the struct members
+   return 0;
+}
+```
+
+
+
+
+
 ### 2.2 Function Overloading <a name="2.2"></a>
 
 [go to top](#top)
@@ -202,3 +286,8 @@ if(! writer2) { //Check to see if the filestream is open
                         /| } O.=.O { |\     
 ```
 
+​    
+
+------
+
+ [![Yeah! Buy the DRAGON a COFFEE!](E:/coding-notes/_assets/COFFEE%20BUTTON%20%E3%83%BE(%C2%B0%E2%88%87%C2%B0%5E).png)](https://www.buymeacoffee.com/methylDragon)

C++/03 C++ - Pointers.md

@@ -28,6 +28,7 @@ I'll be adapting it from the ever amazing Derek Banas: https://www.youtube.com/w
    2.5   [Arrays with Pointers](#2.5)    
    2.6   [Indirection (Pointers of Pointers)](#2.6)    
    2.7   [When to use Pointers and when to use References](#2.7)    
+   2.8   [Memory Management](#2.8)    
 
 
 
@@ -253,7 +254,7 @@ Basic concept: When an array is initialised in C++, each successive array elemen
 ```c++
 // Let's try this out!
 int numbers[5] = {1, 2, 3, 4, 5}; // Initialise an array
-int* numbersPtr = numbers; // And a pointer!
+int* numbersPtr = numbers; // And a pointer which stores the pointer to the first element!
 
 cout << "Before: " << *numbersPtr << endl;
 
@@ -316,7 +317,6 @@ https://stackoverflow.com/questions/5580761/why-use-double-pointer-or-why-use-po
 > - but now you want to change that address.
 > - you could, by doing pointer1 = pointer2, and pointer1 would now have the address of pointer2.
 > - BUT! if you want a function to do that for you, and you want the result to persist after the function is done, you need do some extra work, you need a new pointer3 just to point to pointer1, and pass pointer3 to the function.
-> - here is a fun example (take a look at the output bellow first, to understand!):
 
 Another example of indirection being used, is with strings!
 
@@ -348,8 +348,80 @@ Pointers can also be altered to point to other memory addresses! But references
 
 
 
+### 2.8 Memory Management <a name="2.8"></a>
+
+[go to top](#top)
+
+Read more: http://www.cplusplus.com/doc/tutorial/dynamic/
+
+I have to say it here, since we've covered pointers. The reason why C++ is so powerful (and hard), is because you have to control how memory is managed in the program. This means cleaning up after yourself if you want to no longer use variables, controlling the memory flow, assigning pointers, and all the like. It goes really, really deep.
+
+So here's a small primer! For **dynamic (runtime) memory management.**
+
+
+
+#### **new and new[]**
+
+> You use `new` if you want objects to persist until you `delete` it. But if you don't specifically need that, DO NOT USE NEW because it's expensive memory-wise.
+
+`new` reserves memory, and returns a pointer to the memory that was allocated! If you assign an array, then it returns the pointer to the first element of the array.
+
+```c++
+int * foo; // Initialise a pointer
+int * bar; // Another one
+
+foo = new int; // And allocate memory to it
+bar = new int [5]; // Or perhaps an array of size 5?
+```
+
+>  But be careful! Memory allocated in this way needs to be disposed of manually using `delete.`
+>
+> Otherwise it becomes a memory leak, which, if accumulated enough such that your program runs out of the memory allocated to it, crashes.
+
+
+
+#### **delete and delete[]**
+
+`delete` is how you do garbage disposal. Be wary of using pointers you've deleted though! Since the memory space previously allocated to the pointer could have been used for other things, or would be filled with garbage.
+
+```c++
+delete ptr; // To delete pointers
+delete[] array_ptr; // To delete array pointers
+```
+
+
+
+#### **Assignment Failures**
+
+From: http://www.cplusplus.com/doc/tutorial/dynamic/
+
+If you try to store a variable that will take too much memory than the memory that is available, the assignment statement will fail.
+
+**You can catch this exception!**
+
+Alternatively, if you want to still let it pass, then use `nothrow`, which will return a null pointer instead (which is still bad, and you still have to verify if it worked, so it's less efficient, but easier to write intially...)
+
+```c++
+ foo = new int [5];  // if allocation fails, an exception is thrown 
+
+// Or using (nothrow)
+
+int * bar;
+bar = new (nothrow) int [5];
+if (bar == nullptr) { // Check to see if bar was assigned a null pointer
+  // error assigning memory. Take measures.
+}
+```
+
+
+
 ```
                             .     .
                          .  |\-^-/|  .    
                         /| } O.=.O { |\     
-```
+```
+​    
+
+------
+
+ [![Yeah! Buy the DRAGON a COFFEE!](E:/coding-notes/_assets/COFFEE%20BUTTON%20%E3%83%BE(%C2%B0%E2%88%87%C2%B0%5E).png)](https://www.buymeacoffee.com/methylDragon)