I know that pointers are used to store address of another memory location. The code is as follows:
#include <stdio.h>
main()
{
int a=10;
void *ptr=10;
printf("%u",ptr);
}
My output was: 10
Can we store values in the pointers as in the above program? What is the main use of void pointer?
Can we store values in the pointers as in the above program?
The only values that should be assigned to pointer variable are:
int *foo = &x;);int (*fptr)(const char *, ...) = printf;);NULL (which represents a well-defined "nowhere"). You should not use pointer variables to store arbitrary values for arithmetic computation or display as you do in your example.
The declaration
void *ptr=10;
should have raised a diagnostic; you cannot directly assign an integer value to a pointer variable without a cast. You might want to raise the warning level on the compiler you're using.
The statement
printf("%u",ptr);
invokes undefined behavior, since the type of the argument (void *) doesn't match what the conversion specifier is expecting (unsigned int). It "worked" in the sense that it displayed the value you expected, but that's a matter of luck, not design. It could just as easily have printed out a garbage value.
What is the main use of void pointer?
It serves as a "generic" pointer type. Pointers to different types are not directly assignable to each other; IOW, you can't do something like
char *foo;
double *bar;
foo = bar; // bzzt
without explicitly casting bar to char *:
foo = (char *) bar;
Similarly, if you have a function that takes a pointer parameter of one type, you can't call it with a pointer of a different type:
void f(char *);
...
double x;
f(&x); // bzzt
The one exception to this rule is objects of void * type; they can be assigned without needing a cast:
int x;
void *foo = &x;
and functions that take paramters of type void * can accept arguments of any object pointer type:
void f(void *);
...
double x;
int y;
f(&x);
f(&y);
They're used to implement limited forms of "generic" programming (where the algorithm is the same, but the types are different). The canonical example is the qsort library function, which can sort arrays of any type.
void *ptr=10;
This is not valid C, you need an explicit conversion with a cast like (void *) 10.
printf("%u",ptr);
This is not valid C, you need an explicit conversion with a cast like (unsigned int) ptr.
Regarding the use of void pointers, they are generic object pointers, so you can assign a pointer value of any object pointer type to a void *.
The type of the constant 10 is int; you are assigning an int to a void *. That's crazy, and wrong, there is absolutely no guarantee that you will get 10 when you print the value of ptr. You shouldn't do it. You don't know how pointer values are represented, and you don't have to. You don't care.
The use of void pointers is rather straightforward: it is just a way to deal with generic pointers. For example, you can implement a container of "something" by storing void pointers to the objects being stored. Be aware that you can't dereference it though - you need to cast it back to a valid pointer before doing so.
Also, on a side note, you should use %p to print pointers.
Pointers are meant to store address (memory location) of a variable. So, their size is normally the word size of the OS (like 64bit = 8 byte in 64-bit OS).
By defining the type of pointer like int, char or void, we restrict the use of pointer for specific data type.
By assigning a constant value to the pointer void *ptr=10;, you may have stored value but that's not the proper use pointer, and may cause segmentation fault later on. Always use pointer for storing address of variables like void *ptr = &a;.
A void pointer doesn't define the type of data that it is pointing to. We can use void pointer to store address of variable without knowing its datatype.
No you cant directly store the value to the pointer unless and unless you refer it to something. Pointer assignment like x=y makes y point to the same pointee as x. YOu can consult this for more info Visit http://cslibrary.stanford.edu/106/
