{"id":3398,"date":"2022-11-19T03:32:00","date_gmt":"2022-11-18T22:02:00","guid":{"rendered":"https:\/\/cthecosmos.com\/?p=3398"},"modified":"2022-11-19T03:37:17","modified_gmt":"2022-11-18T22:07:17","slug":"fun-with-pointers","status":"publish","type":"post","link":"https:\/\/cthecosmos.com\/?p=3398","title":{"rendered":"FUN WITH POINTERS"},"content":{"rendered":"\n

Pointers!
A confusing yet curious topic.

What is a POINTER<\/strong>?
Well, it\u2019s a variable that stores the address of another variable.

We often get confused by the dual operation performed by the pointer.
‘&<\/strong>‘ Operator is an address operator that gives the address of a particular variable.
‘*<\/strong>‘ Operator is an indirection operator, that refers to the value pointed by the pointer.

A simple Initialization of a pointer would be:

int *ptr = NULL;
int a = 500;
ptr = &a;<\/strong>

Well, that’s it, the pointer ‘ptr<\/strong>‘ now points to the address of a<\/strong>.

By using the ‘*<\/strong>‘ operation, we can indirectly change the value that is stored in a, ex:
*ptr = 1000;<\/strong>

Now the variable ‘a<\/strong>‘ has the value 1000<\/strong>.

Ok, Now let’s understand how the pointer acts on different types and different types of pointers such as:
1) Integer Pointer
2) Character Pointer
3) Float Pointer
4) Double Pointer
5) Dangling Pointer
6) Wild Pointer
7) Null Pointer
8) Void Pointer…<\/p>\n\n\n\n

Initializations:<\/strong>
<\/p>\n\n\n

\nint main(int argc, char **argv)\n{\n\/\/ Fun with integer variable with different pointer types\nint int_var     =   13 ;\nint *ptr        =   NULL;                  \/\/ A interger pointer\nvoid *void_ptr  =   NULL;                  \/\/ A void pointer\/Generic pointer\n\nint *int_ptr        = NULL;              \/\/ A integer pointer\nchar *char_ptr      = NULL;            \/\/ A character pointer\nfloat *float_ptr    = NULL;          \/\/ A float pointer\ndouble *double_ptr  = NULL;        \/\/ A double pointer\n\n\/\/ Assigning the integer value to different types of pointers\n\nint_ptr     =  &int_var;        \/\/ Integer value to integer pointer\nchar_ptr    =  &int_var;        \/\/ Integer value to character pointer | Should get a warning\nfloat_ptr   =  &int_var;        \/\/ Integer value to float pointer | Should get a warning\ndouble_ptr  =  &int_var;        \/\/ Integer value to double pointer | Should get a warning\n\n\/\/NOTE: %p gives the address \n\n\/\/ Lets print em\n<\/pre><\/div>\n\n\n
Starting with Int:<\/strong>
<\/p>\n\n\n
\nprintf("Address of int_var= %p\\n",&int_var);\n\nprintf("\\nAddress of the int pointer is %p\\n",&int_ptr);\nprintf("\\nAddress of the char pointer is %p\\n",&char_ptr);\nprintf("\\nAddress of the float pointer is %p\\n",&float_ptr);\nprintf("\\nAddress of the double pointer is %p\\n",&double_ptr);\n\nprintf("\\nAddress in the int pointer is %p, Value stored in the pointer is %d\\n",int_ptr,*int_ptr);\nprintf("\\nAddress in the char pointer is %p, Value stored in the pointer is %c\\n",char_ptr,*char_ptr);\nprintf("\\nAddress in the float pointer is %p, Value stored in the pointer is %f\\n",float_ptr,*float_ptr);\nprintf("\\nAddress in the double pointer is %p, Value stored in the pointer is %lf\\n",double_ptr,*double_ptr);\n\nprintf("\\n~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~~~~\\n");\n<\/pre><\/div>\n\n\n
\"\"<\/figure>\n\n\n\n
Now Char:<\/strong>
<\/p>\n\n\n
\nchar char_var = 'c';\n\nint_ptr     =  &char_var;        \/\/ Char value to integer pointer | Should get a warning\nchar_ptr    =  &char_var;        \/\/ Char value to character pointer \nfloat_ptr   =  &char_var;        \/\/ Char value to float pointer | Should get a warning\ndouble_ptr  =  &char_var;        \/\/ Char value to double pointer | Should get a warning\n\nprintf("Address of char_var=  %p\\n",&char_var);\n\nprintf("\\nAddress of the int pointer is %p\\n",&int_ptr);\nprintf("\\nAddress of the char pointer is %p\\n",&char_ptr);\nprintf("\\nAddress of the float pointer is %p\\n",&float_ptr);\nprintf("\\nAddress of the double pointer is %p\\n",&double_ptr);\n\nprintf("\\nAddress in the int pointer is %p, Value stored in the pointer is %d\\n",int_ptr,*int_ptr);\nprintf("\\nAddress in the char pointer is %p, Value stored in the pointer is %c\\n",char_ptr,*char_ptr);\nprintf("\\nAddress in the float pointer is %p, Value stored in the pointer is %f\\n",float_ptr,*float_ptr);\nprintf("\\nAddress in the double pointer is %p, Value stored in the pointer is %lf\\n",double_ptr,*double_ptr);\n\nprintf("\\n~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~~~~\\n");\n<\/pre><\/div>\n\n\n
\"\"<\/figure>\n\n\n\n
Now to Float:<\/strong>
<\/p>\n\n\n
\nfloat float_var = 3.141;\n\nint_ptr     =  &float_var;        \/\/ Float value to integer pointer | Should get a warning\nchar_ptr    =  &float_var;        \/\/ Float value to character pointer | Should get a warning\nfloat_ptr   =  &float_var;        \/\/ Float value to float pointer \ndouble_ptr  =  &float_var;        \/\/ Float value to double pointer | Should get a warning\n\n\nprintf("Address of float_var=  %p\\n",&float_var);\n\nprintf("\\nAddress of the int pointer is %p\\n",&int_ptr);\nprintf("\\nAddress of the char pointer is %p\\n",&char_ptr);\nprintf("\\nAddress of the float pointer is %p\\n",&float_ptr);\nprintf("\\nAddress of the double pointer is %p\\n",&double_ptr);\n\nprintf("\\nAddress in the int pointer is %p, Value stored in the pointer is %d\\n",int_ptr,*int_ptr);\nprintf("\\nAddress in the char pointer is %p, Value stored in the pointer is %c\\n",char_ptr,*char_ptr);\nprintf("\\nAddress in the float pointer is %p, Value stored in the pointer is %f\\n",float_ptr,*float_ptr);\nprintf("\\nAddress in the double pointer is %p, Value stored in the pointer is %lf\\n",double_ptr,*double_ptr);\n\nprintf("\\n~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~~~~\\n");\n<\/pre><\/div>\n\n\n
\"\"<\/figure>\n\n\n\n
And Double:<\/strong><\/p>\n\n\n
\ndouble double_var = 12365.117784596;\n\nint_ptr     =  &double_var;        \/\/ Double value to integer pointer | Should get a warning\nchar_ptr    =  &double_var;        \/\/ Double value to character pointer | Should get a warning\nfloat_ptr   =  &double_var;        \/\/ Double value to float pointer | Should get a warning\ndouble_ptr  =  &double_var;        \/\/ Double value to double pointer \n\n\nprintf("Address of double_var=  %p\\n",&double_var);\n\nprintf("\\nAddress of the int pointer is %p\\n",&int_ptr);\nprintf("\\nAddress of the char pointer is %p\\n",&char_ptr);\nprintf("\\nAddress of the float pointer is %p\\n",&float_ptr);\nprintf("\\nAddress of the double pointer is %p\\n",&double_ptr);\n\nprintf("\\nAddress in the int pointer is %p, Value stored in the pointer is %d\\n",int_ptr,*int_ptr);\nprintf("\\nAddress in the char pointer is %p, Value stored in the pointer is %c\\n",char_ptr,*char_ptr);\nprintf("\\nAddress in the float pointer is %p, Value stored in the pointer is %f\\n",float_ptr,*float_ptr);\nprintf("\\nAddress in the double pointer is %p, Value stored in the pointer is %lf\\n",double_ptr,*double_ptr);\n\nprintf("\\n~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~~~~\\n");\n\n\n\n\/*\nSo you see the effects of wrong type assignment.     \nWrong type casting is dangerous and can lead to breaking of the system. Be careful of the type you are using for the varaible\nMore about void soon.\n*\/\n\n printf("\\n~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~~~~\\n");\n\/*\n  Let us check with some different pointer types.\n  1) Wild Pointer\n  2) Dangling Pointer\n  3) NULL Pointer\n  4) Void Pointer\n*\/\n<\/pre><\/div>\n\n\n
\"\"<\/figure>\n\n\n\n
Dangling Pointer:<\/strong><\/p>\n\n\n
\n \/\/ A pointer pointing to a location that has been deleted\/freed is known as Dangling Pointer\n\nint *dangling =  NULL ; \/\/ NULL Pointer: Initializing a pointer with NULL is known as NULL pointer\n\/*\n What happens if you de-reference a NULL pointer? Well, its not a good idea as it will lead to Segmentaiton Fault. \n Yeah , don't dereference a NULL pointer. It is a great practice to check if a pointer is NULL or not before de-referencing it.\n*\/\n\n\/\/printf("DANGLING POINTER contains the value %d\\n",*dangling);\n\n\/\/Now with Dangling\nprintf("\\n~~~~~~~~~~~~~~~~~~~~~  ABOUT DANGLING  ~~~~~~~~~~~~~~~~~~~\\n");\nif(dangling ==NULL)\n    printf("\\n\\nWARNING! It is a NULL pointer. Dosen't contain any address\\n\\n");\n\ndangling=(int*)malloc(sizeof(int)); \/\/ Initializes memory to store 4 integers\nprintf("\\nSize of Integer varaiable is : %ld\\n",sizeof(int));\n\nif(dangling)\nprintf("\\nSome Random varaibles are stored here. The pointer does have an address where data can be placed\\n");\nprintf("The random variable is: %d\\n",*dangling);\n\n*dangling = 0xffffffff;\nprintf("Address of value pointed by dangling: %p\\n",dangling);\nprintf("Address of value  dangling: %p\\n",&dangling);\n\nprintf("\\nValue stored by Dangling Pointer: %x\\n",*dangling);\n\n<\/pre><\/div>\n\n\n
\"\"<\/figure>\n\n\n
\n\/\/ What if i do *dangling+1 ? Let's check\n\nfor(int i=0;i<6;i++)\n{\n    *(dangling+i)=350000+i;\n    printf("Address  of *(dangling  + %d): %p, Value  stored by *(dangling  + %d) is: %d\\n",i,(dangling  + i),i,*(dangling+i));\n}\n\n\/\/ Why the above? Lets see by using the free.\n\nfree(dangling);\n\/\/ Once freed, the "dangling" pointer that we declared becomes a Dangling Pointer\n\n\nprintf("\\nAFTER FREEING:\\n");\nprintf("\\nValue stored by Dangling Pointer: %x\\n",*dangling); \/\/Pointer points to the memory after being freed\n\/\/ free() dosen't change the value of dangling, but it still points to chuck of memory that malloc() gave.\n\/\/ Now the heap allocator, the one responsible for dynamic memory allocation is ready to give away that location.\n\nfor(int i=0;i<6;i++)\n{\n\n    printf("Address  of *(dangling  + %d): %p, Value  stored by *(dangling  + %d) is: %d\\n",i,(dangling  + i),i,*(dangling+i));\n}\n\n\/*  Observed anything? Yep.\n    The starting 4 locations pointed by the pointer are storing garbage value. but the remaining locations store the values that\n    are initialized. But the base pointer is lost once freed, hence it is difficult to get the values from those locations \n    unless they are stored.\n*\/\n<\/pre><\/div>\n\n\n
\"\"<\/figure>\n\n\n\n
About Wild Pointer:<\/strong><\/p>\n\n\n
\n\/\/ ~~~~~ ABOUT WILD ~~~~~~~\n\/\/ So now what are wild pointers?\n\/\/ The uninitialized pointers are called as WILD POINTERS\n\n\nint *Wild_ptr;\n\/*Yeah, that's it. That's the WILD POINTER. A pointer that is not initialized. \nIf this Wild_ptr is dereferrenced, we will see unexpected behaviour by the compiler, like Segmentation Fault.*\/\n\n\/\/printf("Address  of Wild_ptr : %p, Value  stored by *(Wild_ptr) is: %d\\n",Wild_ptr,*(Wild_ptr));\n\/\/ The above gives Seg Fault\n<\/pre><\/div>\n\n\n
About Void:<\/strong>
<\/p>\n\n\n
\nprintf("\\n~~~~~ ABOUT VOID ~~~~~~~\\n");\n\/\/Now let us look at void pointer\nint_var = 215;\n\n void_ptr    =  &int_var;      \/\/   Integer value to void pointer | ERROR! *\/\n \/\/void_ptr    =  &char_var;      \/\/   Char value to void pointer | ERROR! *\/\n \/\/void_ptr    =  &float_var;      \/\/ Float value to void pointer | ERROR! *\/\n \/\/void_ptr    =  &double_var;      \/\/ Double value to void pointer | ERROR! *\/\n\n\/\/printf("\\nVoid pointer address is: %p, Value stored in the pointer is %d\\n",*void_ptr); \n\/\/ The above statement should give error as it is a must to externally type cast void pointer    \n\n\/\/ You can either type cast it where it is being used or you can type cast it during initialization\n\nprintf("\\nVoid pointer(int *) address is: %p, Value stored in the pointer is %d\\n",void_ptr,*((int *)void_ptr)); \n\/\/ The above statement would be the right use of void pointer\n\n\/\/ What if the external type casting is wrong for void pointer?\n\/\/ Lets find out\nprintf("\\nVoid pointer(char *) address is: %p, Value stored in the pointer is %c\\n",void_ptr,*((char *)void_ptr)); \nprintf("\\nVoid pointer(float *) address is: %p, Value stored in the pointer is %f\\n",void_ptr,*((float *)void_ptr)); \nprintf("\\nVoid pointer(double *) address is: %p, Value stored in the pointer is %lf\\n",void_ptr,*((double *)void_ptr)); \n\n<\/pre><\/div>\n\n\n
\"\"<\/figure>\n\n\n
\n\n\/\/ THE TRUE WAY TO USE THE %p. Use it with generic pointer and a good use of void pointer is as below\nvoid *true_ptr = NULL;\nint some_int_val = 10;\nchar some_char_val = '1';\nfloat some_float_val = 3.141;\ndouble some_double_val  = 3.14159265358979;\n\ntrue_ptr = &some_int_val;\nprintf("\\nAddress of true_ptr is: %p, Address pointed by true_ptr: %p, Value in  true_ptr:%d \\n", \n&true_ptr,  true_ptr, *((int*)true_ptr));    \n\ntrue_ptr = &some_char_val;\nprintf("\\nAddress of true_ptr is: %p, Address pointed by true_ptr: %p, Value in  true_ptr:%c \\n", \n&true_ptr,  true_ptr, *((char*)true_ptr));    \n\ntrue_ptr =  &some_float_val;\nprintf("\\nAddress of true_ptr is: %p, Address pointed by true_ptr: %p, Value in  true_ptr:%f \\n", \n&true_ptr,  true_ptr, *((float*)true_ptr));    \n\ntrue_ptr = &some_double_val;\nprintf("\\nAddress of true_ptr is: %p, Address pointed by true_ptr: %p, Value in  true_ptr:%lf \\n", \n&true_ptr,  true_ptr, *((double*)true_ptr));    \n\n\/* As you can see in the output, the same pointer is pointing to different address.\n Yeah, a void pointer can be used to derefence any pointer type.*\/\nreturn 0;\n}\n<\/pre><\/div>\n\n\n
\"\"<\/figure>\n\n\n\n
CAME THIS FAR? Why not go ahead with Dynamic Memory Allocation?
Well, there are just a few handfull of Dynamic Mem functions.
1) MALLOC
2) CALLOC
3) REALLOC
4) FREE
Let us take that up in another post.<\/p>\n\n\n\n
Stay Tuned, See you Soon .<\/strong><\/p>\n\n\n\n
Page Image credit: Reddit<\/p>\n","protected":false},"excerpt":{"rendered":"
Pointers!A confusing yet curious topic. What is a POINTER?Well, it\u2019s a variable that stores the address of another variable. We often get confused by the dual operation performed by the pointer.‘&‘ Operator is an address operator that gives the address of a particular variable.‘*‘ Operator is an indirection operator, that refers to the value pointed […]<\/p>\nRead More FUN WITH POINTERS<\/span><\/a>","protected":false},"author":120055267,"featured_media":3420,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_jetpack_newsletter_access":"","_jetpack_dont_email_post_to_subs":false,"_jetpack_newsletter_tier_id":0,"_jetpack_memberships_contains_paywalled_content":false,"_wpcom_ai_launchpad_first_post":false,"_jetpack_hide_featured_image":false,"_jetpack_featured_image_duplicate_dismissed":0,"_jetpack_feature_clip_id":0,"_jetpack_memberships_contains_paid_content":false,"footnotes":"","jetpack_publicize_message":"{title}\n\n{excerpt}\n\n{url}","jetpack_publicize_feature_enabled":true,"jetpack_social_post_already_shared":false,"jetpack_social_options":{"image_generator_settings":{"template":"highway","default_image_id":0,"font":"","enabled":false},"version":2},"_wpas_customize_per_network":false,"jetpack_post_was_ever_published":false},"categories":[1342,28627],"tags":[2426,772321181,22341966,772321191,116003636,264,20863,196,5198471],"class_list":["post-3398","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-education","category-embedded","tag-c","tag-education","tag-embd","tag-embedded","tag-embedded-c-2","tag-learning","tag-pointers","tag-programming","tag-segmentation-fault","fallback-thumbnail"],"aioseo_notices":[],"aioseo_head":"\n\t\t\n\t\n\t\n\t\n\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t