#include using namespace std; //TOME A : LESSON 2 /*Hello Everyone! This is the second code I'm making to help begginers understand the pointers better. If you haven't seen Lesson 1 yet, It will be right in my profile, so don't hesitate to give it a look and feel free to ask me questions. One last thing, I am not getting awarded for doing this at all. But I feel that I should help some people fulfill their dreams because programming is a very usefull skill to have these days and it can give you many oportunities. DISCLAIMER: Forgive me for my english :) Last time we talked about the very basics of the pointers. To sum up the last lesson. There are 2 basic types of pointers, the pointer and the reference, their use is similar but they have differencies. It is possible to create any program without using a single pointer. But it is going to have concequencies and the code might look bad. With these in our minds lets continue our journey understanding the pointers! /////////START HERE//////////////// In the following lessons I might use: //NR next to lines of code or on top of blocks of codes. It stands for NOT RECOMENDED, the code is just an example to help you understand how something works; The code is either very (stupid) and useless or even could result to bad flow of the program. By end of the tome I will try to give a lot of examples of where to use pointers, but at this point of your C++ course in sololearn there is pretty much no reason why would you use a pointer. The reason why you learn pointers at this point it is to make make it easier for you to learn other things later. So in my opinion if you want to keep up finish the C++ course and then these lessons will be a lot easier for you! Now let's get right into it. When we run our program, it runs in the CPU and our variables are stored in RAM. That means that a some part of the RAM, during run time is being used by the program. We will refer to this part as the 'memory' ( RAM is also a memory but we will be talking about our program during these lessons). This memory is splited into 2 main parts; the Heap Memory and the Stack Memory. Till now we only know how to store data in the stack. Every time we made a variable it was being stored into the stack. */ void introduction_to_memory(){ int value = 50; //gets stored into the stack cout << &value << endl; //And the momory address that it has is an adress in the stack. //We can imagine stack like a skycraper. When we enter it from the front door we will be on the ground floor. In the case of memory that is the adress 0 since there are no appartments on the ground floor! Some families living in the skycraper are richer than others so they owe more appartments. A char variable for example ows only one because it is poor. char letter = 'w'; float height = 6.4; cout << "Size of letter: " << sizeof(letter) << endl; cout << "Size of height: " << sizeof(height) << endl; //Characters (1 byte) take less memory space than Floats (4 bytes). //But sometimes when we code in C++ we would prefere if some variables were not stored in the stack but in the heap. Heap gives us the oportunity to store data and delete it if we want to and when we want to. Also data stored in heap does not get automaticaly deleted when it reaches the end of the scope. Also variables and objects stored there don't have a name so we won't have to fear if a name gets repeated twice. All these might look confusing but bare with me. Let's declare a variable in Heap. In order to do that we need to apply the following syntax: // new ; new int; //NR //That's all, right now a new variable has been created in the heap! But wait how do we actualy use it? It does not have a name! That's where pointers come in. We will use them to store the adress of the new variable in them. But fist let's talk about our new keyword: new. // new is an operator and it has two uses. It searches for free space in the Heap memory and when it finds it 'creates' a new variable there, with that specific memory. This process is called MEMORY ALLOCATION and allocating memory in heap is slower than storing data in stack because in stack the only thing that happens when a new variable is created is that an index is being moved to the next free memory space. Secondly new, returns the memory that it allocated. Let's see that, but first I will make us a scope { int * ptr; //Creating a pointer ptr = new int; //what we did in these lines of code, is creating a pointer variable and make it point in the memory adress of a NEW integer in the heap. That means that the int we created previously is completly different than the last one we made. And the problem is that it will now exist there until our program stops running and we can do nothing about it. Data stored in heap like that is called GARBAGE and creating garbage is always bad and should avoided at all costs. Because Heap, just like stack, is not infinite. If it runs out, our program will crash and that will be a problem. So we need to keep track of how we treat our data and Always deleting it when we don't need it any more. That's where we need the DELETE delete ptr; //The syntax is simple: //delete . //Notice that: //> I don't de-reference (* operator) when I use delete. That's because I need the memory adress of the variable that is stored in heap and not its value. //> What we are doing here is freeing up the memory we allocated previously in the heap. Which means that this code is valid: delete new int; //NR //we are freeing up the memory we just allocated //...We did not delete the pointer. Does that mean that this pointer still points to a memory adress of a non existing variable in heap? cout << ptr << endl; //Yes it does! And that is valid, but be careful, trying de-reference this its value to an operation for example, will give a runtime error or an UNDEFINED BEHAVIOR. Undefined behaviors mean that the compiler does not know how to handle a situation. Most C++ compilers can handle them and them correctly but they still have risks. //These pointers are called DANGLING POINTERS. Dangling pointers do not only occur when freeing up memory that they are pointing to. There are several more ways to *achive* one but I will talk about this later. Now, //Let's re-define our dangling pointer: ptr = &value; //making it point to the memory of another stack variable ptr = nullptr; ptr = NULL; ptr = 0; //These 3 are identical, we are making them point to 0, which is a valid adress but it can not be used ptr = new int; //or even making it point to a new heap adress } //Whoops NR //I just left the scope I previously created! Now the pointer which I declared within that scope has been deleted and I just made Garbage again! This is again an example to avoid. It won't happen anything if it happens a few times but it would be nicer if it didn't happen at all. //This whole concept of allocating memory, freeing it up, and then allocating it again is called DYNAMIC MEMORY and it is only possible with the power of pointers! } int main() { return 0; }

Pointers For Beginners II