Pointers: Program 1 to 5

deltanode · deltanode · commit 82d1f2d983e5 · 2021-12-27T18:34:53.000+05:30
diff --git a/10_pointers/01_address_of_operator.cpp b/10_pointers/01_address_of_operator.cpp
@@ -0,0 +1,33 @@
+/* 
+    Address of Operator (&)
+    - It is used to find address of variable
+    - C++ display address in HexaDecimal format (Base 16)
+*/
+
+#include <iostream>
+using namespace  std;
+
+int main(){
+    int x=10;
+    cout << "[Integer] Address of x [&x]: " << &x << endl;
+
+    float y=9.5;
+    cout << "[Float] Address of y [&y]: " << &y << "\n\n";
+
+    // It doesn't work for character variables bcz of operator overloading
+    char ch = 'A';
+    cout << "[Character] Address of ch [&ch]: " << ch << endl;    
+
+    // Explicit typecasting from char* to void*
+    cout << "[Character] Address of ch [(void*)&ch]: " << (void*)&ch << endl;
+    return 0;
+}
+
+/* 
+OUTPUT: 
+
+    [Integer]   Address of x [&x]:             0x7ffd67f494e0
+    [Float]     Address of y [&y]:             0x7ffd67f494e4
+    [Character] Address of ch [&ch]:           A
+    [Character] Address of ch [(void*)&ch]:    0x7ffd67f494df
+*/
diff --git a/10_pointers/02_pointers.cpp b/10_pointers/02_pointers.cpp
@@ -0,0 +1,87 @@
+/* 
+    Pointers
+    - Pointer is a variable that stores the address of another variable
+      Syntax:   datatype * variable_name
+    - The size of pointer doesn't depend upon datatype. It is same for all. 
+*/
+
+#include <iostream>
+using namespace  std;
+
+int main(){
+    int a = 10;
+    int b = 20;
+    cout << "&a: " << &a << endl;
+    cout << "&b: " << &b << "\n\n";
+
+    int *p = &a;              // declaration + initializaton
+    int *pt;                  // declaration   [currently storing garbage value]
+
+    /* 
+       Sometimes it is useful to make our pointers point to nothing. This is called a null pointer. 
+       We assign a pointer a null value by setting it to address 0.  
+    */
+    int *ptr = 0;             // NULL pointer
+
+    // store the address of variable a
+    ptr = &a;                           // assignment
+    cout << "ptr: " << ptr << endl;
+
+    // Re-assign another address to ptr pointer
+    ptr = &b;
+    cout << "ptr: " << ptr << endl;
+
+    return 0;
+}
+
+/* 
+OUTPUT: 
+
+    &a: 0x7fff1ce2db00
+    &b: 0x7fff1ce2db04
+
+    ptr: 0x7fff1ce2db00
+    ptr: 0x7fff1ce2db04
+
+
+More About Pointers:
+
+- Pointer & Arithmetic
+    > Addition, Multiplication, Division of two addresses doesn’t make any sense
+    > Addition of an address by a constant integer value 
+      i.e. ptr +5 means address of cell which is 5 * sizeof(*ptr) away from ptr.
+    > Similar for subtraction
+    > Again Multiplying/Dividing an address with some constant value doesn’t make any sense
+    > Subtracting two address of same type would give you number of elements between them
+
+- Arrays & Pointers
+    > An Array is actually a pointer that points to the first element of the array! 
+      Because the array variable is a pointer, you can dereference it, which returns array element 0.
+    > a[i] is same as *(a + i)
+
+- Difference – Arrays & Pointers
+    - The sizeof operator
+        > sizeof(array) returns the amount of memory used by all elements in array
+        > sizeof(pointer) only returns the amount of memory used by the pointer variable itself
+    
+    - The & operator
+        > &array is an alias for &array[0] and returns the address of the ﬁrst element in array
+        > &pointer returns the address of pointer
+    
+    - String literal initialization of a character array
+        > char array[] = “abc” sets the ﬁrst four elements in array to ‘a’, ‘b’, ‘c’, and ‘\0′
+        > char *pointer = “abc” sets pointer to the address of the “abc” string 
+          (which may be stored in read-only memory and thus unchangeable)
+    
+    - Assignment/Re-assigment
+        > Pointer variable can be assigned a value whereas array variable cannot be.
+          Eg:  int a[10];
+               int *p;
+               p=a;     // legal
+               a=p;     // illegal
+    
+    - Arithmetic
+        > Arithmetic on pointer variable is allowed but array can’t be incremented/decremented.
+          Eg:  p++;     // legal
+               a++;     // illegal
+*/
diff --git a/10_pointers/03_dereference_operator.cpp b/10_pointers/03_dereference_operator.cpp
@@ -0,0 +1,65 @@
+/* 
+    Topic - Dereference Operator (*)
+
+    asterisk (*) has many use cases :-
+        1. For multiplication           //  5*2
+        2. to declaring pointer         //  int * ptr;
+        3. to dereference any address   //  *ptr + 1
+    
+    Dereference:
+     - In simple words, dereferencing means accessing the value from a certain memory location against 
+       which that pointer is pointing.
+     - So, by dereferencing pointer we can access the variable, in which they are pointing to.
+       
+*/
+
+#include <iostream>
+using namespace  std;
+
+int main(){
+    int a = 10;
+    int *ptr = &a;             // declaration & initilization
+
+    cout << "&a - " << &a << endl;                    // OUTPUT: (Address of bucket "a")
+    cout << "ptr - " << &a << "\n\n";                 // OUTPUT: (Address of bucket "a")
+    
+    // dereferencing
+    cout << "*(&a) - " << *(&a) << endl;              // OUTPUT: 10 (value -> address a)
+    cout << "*(ptr) - " << *(ptr) << "\n\n";          // OUTPUT: 10 (value -> address stored at ptr) 
+    
+    cout << "*(&ptr) - " << *(&ptr) << endl;          // OUTPUT: (Address of bucket "a")    [=> value stored at ptr)  =>  value at &ptr] 
+    cout << "&(*ptr) - " << &(*ptr) << "\n\n";        // OUTPUT: (Address of bucket "a")    [i.e  *ptr = bucket "a"] 
+
+    // Know the difference :-
+    cout << "*(ptr) + 1 - " << *(ptr)+1 << endl;      // OUTPUT:  11  (i.e 10+1)
+    cout << "*(ptr+1) - " << *(ptr+1) << "\n\n";      // OUTPUT:  Unknown/Garbage Value  
+                                                      //          (value at next memory address)
+
+    // Double Pointer
+    int ** newptr = &ptr;
+    cout << "Double Pointer: " << endl;
+    cout << "newptr: " << newptr << endl;             // OUTPUT: (address of ptr)
+    cout << "&ptr: " << &ptr << endl;                 // OUTPUT: (address of ptr)
+
+    return 0;
+}
+
+/* 
+OUTPUT: 
+
+    &a - 0x7ffe49b6db94
+    ptr - 0x7ffe49b6db94
+
+    *(&a) - 10
+    *(ptr) - 10
+
+    *(&ptr) - 0x7ffe49b6db94
+    &(*ptr) - 0x7ffe49b6db94
+
+    *(ptr) + 1 - 11
+    *(ptr+1) - 1236720532
+
+    Double Pointer: 
+    newptr: 0x7ffe49b6db98
+    &ptr: 0x7ffe49b6db98
+*/
diff --git a/10_pointers/04_pass_by_reference.cpp b/10_pointers/04_pass_by_reference.cpp
@@ -0,0 +1,49 @@
+/* 
+    Topic - Pass by Reference Using Pointers
+
+    Pass by Value :     Passing the copy of variable
+    Pass by Reference:  Passing the address of variable
+       
+*/
+
+#include <iostream>
+using namespace  std;
+
+// call by value
+void increment_1(int num){        // variable
+    num = num +1;
+    cout << "[Call by Value] a: "<< num << endl;
+}
+
+// call by reference
+void increment_2(int *num){        // pointer
+    *num = *num +1;
+    cout << "[Call by reference] b:"<< *num << endl;
+}
+
+int main(){
+    int a = 10;
+    int b = 10;
+
+    cout << "a : "<< a << endl;
+    increment_1(a);                             // Passing the copy of variable
+    cout << "[Inside Main] a: "<< a << endl;
+
+    cout << "\nb : "<< b << endl;
+    increment_2(&b);                            // Passing the address of variable
+    cout << "[Inside Main] b: "<< b << endl;
+
+
+    return 0;
+}
+
+/* 
+OUTPUT: 
+    a : 10
+    [Call by Value] a: 11
+    [Inside Main] a: 10
+
+    b : 10
+    [Call by reference] b:11
+    [Inside Main] b: 11
+*/
diff --git a/10_pointers/05_reference_variable.cpp b/10_pointers/05_reference_variable.cpp
@@ -0,0 +1,59 @@
+/* 
+    Topic - References in C++
+    
+    Reference Variable
+    - When a variable is declared as a reference, it becomes an alternative name for an existing variable.
+    - A variable can be declared as a reference by putting ‘&’ in the declaration. 
+*/
+
+#include <iostream>
+using namespace  std;
+
+
+int main(){
+    int num = 10;
+
+    int &ref = num;    // ref is a reference to num
+    cout << "ref : "<< ref << endl;
+
+    ref = 20;          // value of num(alias name ref) is now changed to 20.
+    cout << "ref : "<< ref << endl;
+    
+    num = 30;          // value of num is now changed to 20.
+    cout << "ref : "<< ref << endl;
+
+    return 0;
+}
+
+/* 
+OUTPUT: 
+    ref : 10
+    ref : 20
+    ref : 30
+
+
+More About References Variable:
+
+- Reference Variable:
+    > A reference variable is an alias, that is, another name for an already existing 
+      variable/memory instance.
+    > Once a reference is initialized with a variable, either the variable name or the reference
+      name may be used to refer to the variable.
+    > The reference variable once deﬁned to refer to a variable cannot be changed to 
+      point to other variable.
+
+- Defining Reference Variable:
+    > Reference variables are deﬁned by using '&' symbol in the deﬁnition.
+    > Since they do not have any storage of their own and are just another name for the
+      existing storage, they need to initialized before using them.
+    > Eg: int x;
+          int &y = x;
+      The exisiting memory X will now also have another name Y.
+
+- Reference Variable VS Pointer Variable
+    > You cannot have NULL references. You must always be able to assume that a reference 
+      is connected to a legitimate piece of storage.
+    > Once a reference is initialized to an object, it cannot be changed to refer to another object. 
+      Pointers can be pointed to another object at any time.
+    > A reference must be initialized when it is created. Pointers can be initialized at any time.
+*/
