Thread: Need help on pointer to VOID

void *v;

printf( "%d", &v );

You actually can dereference a void pointer. You just have to type cast it to whatever type you're dereferencing it as. If it points to an int, dereference it as if you were using a pointer to an integer by type casting.


Quzah.

Originally posted by Unregistered

every object has a size , sizeof(void *) makes perfect sense ,
i.e.,
if I declare
void *p;
p is an object , it takes up some size in memory , sizeof (p) or sizeof(void *) will tell us how many bytes it takes up
sizeof(void) doesnt make sense though , as there is no type named void , if sizeof(void *) didnt make sense we would not be able to dynamically allocate a particular number of void size pointers .

Hm. Close. 'sizeof( void* )' only give you the size of the pointer. It doesn't give you the size of what it points at, because what it poitns at could be anything.

All pointers take up exactly the same amount of space, IIRC. It is simply a memory address. This is basicly why void poitners work.

Prelude states that sizeof doesn't work correctly with dynamicly allocated memory. I suspect this goes doubly for trying to get the size of something a void pointer points at.

That said, no, you cannot simply:

int x;
void *v = &x;

sizeof( v );

...and expect it to tell you the size of the integer (object) it points at. In this case, the size would like ly happen to be the same, because the size of an ingeter on a 32 bit compiler happens to be the same size as a pointer.

Code:

int main ( void )
{
    printf("%d\n", sizeof( int ) );
    printf("%d\n", sizeof( int* ) );
    printf("%d\n", sizeof( char* ) );
    printf("%d\n", sizeof( float* ) );
    printf("%d\n", sizeof( void* ) );
     return 0;
}

Quzah.

>I suspect this goes doubly for trying to get the size of something a void pointer points at.
It does, in a way. If you try to get the size of a void pointer then you will simply get the size of a pointer, but if you cast and dereference a void pointer then sizeof will return the size of the data type you cast the void pointer to. Pretty straight forward in it's own twisted way, but what's really interesting is when you dereference a void pointer to a char pointer you get the size of a char and not a char pointer. Here's a fun little test to see just what can happen:

Code:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main ( void )
{
  char c = 'a', *cp;
  double f = 1.2f, *fp;
  void *vf, *vfp, *vc, *vcp;

  fp = malloc ( sizeof ( double ) );
  cp = malloc ( 10 * sizeof ( char ) );
  if ( fp != NULL && cp != NULL ) {
    *fp = 2.3f;
    strcpy ( cp, "Test" );

    vf = &f;
    vfp = fp;
    vc = &c;
    vcp = cp;

    printf ( "Test 1: %u %u\n", sizeof f, sizeof *fp );
    printf ( "Test 2: %u %u\n", sizeof f, sizeof fp );
    printf ( "Test 3: %u %u\n", sizeof vf, sizeof vfp );
    printf ( "Test 4: %u %u\n", sizeof *(double *)vf, sizeof *(double *)vfp );
    printf ( "Test 5: %u %u\n\n", sizeof *(float *)vf, sizeof *(float *)vfp );

    printf ( "Test 6: %u %u\n", sizeof c, sizeof *cp );
    printf ( "Test 7: %u %u\n", sizeof c, sizeof cp );
    printf ( "Test 8: %u %u\n", sizeof *(char *)vc, sizeof *(char *)vcp );
    printf ( "Test 9: %u %u\n", sizeof *(double *)vc, sizeof *(double *)vcp );
    printf ( "Test 10: %u %u\n", sizeof *(char *)vc, sizeof *(char *)vcp );

    free ( fp );
    free ( cp );
  }
  return 0;
}

-Prelude

Why do you misrepresent what I wrote ?
sizeof (a) will tell you what the size of a is and not what it points to (I did not imply that either directly or indirectly ) a might not even be a pointer ,similarly sizeof(void *) tells you what the sizeof of a "void *" is (which happens to be a pointer type), and since there are objects of type "void *" , it will tell you how much space one object of type "void *" will take ,just as sizeof(int *) will tell what the size of an object of type "int *" is ,not the size of int . sizeof works perfectly as it is supposed to , nothing breaks down in case of dynamically allocated memory .

Originally posted by quzah


Hm. Close. 'sizeof( void* )' only give you the size of the pointer. It doesn't give you the size of what it points at, because what it poitns at could be anything.




Quzah.

It does not do so because sizeof is not supposed to do so.
pinko

Originally posted by Prelude
>I suspect this goes doubly for trying to get the size of something a void pointer points at.
It does, in a way. If you try to get the size of a void pointer then you will simply get the size of a pointer, but if you cast and dereference a void pointer then sizeof will return the size of the data type you cast the void pointer to. Pretty straight forward in it's own twisted way, but what's really interesting is when you dereference a void pointer to a char pointer you get the size of a char and not a char pointer. Here's a fun little test to see just what can happen:

Code:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main ( void )
{
  char c = 'a', *cp;
  double f = 1.2f, *fp;
  void *vf, *vfp, *vc, *vcp;

  fp = malloc ( sizeof ( double ) );
  cp = malloc ( 10 * sizeof ( char ) );
  if ( fp != NULL && cp != NULL ) {
    *fp = 2.3f;
    strcpy ( cp, "Test" );

    vf = &f;
    vfp = fp;
    vc = &c;
    vcp = cp;

    printf ( "Test 1: %u %u\n", sizeof f, sizeof *fp );
    printf ( "Test 2: %u %u\n", sizeof f, sizeof fp );
    printf ( "Test 3: %u %u\n", sizeof vf, sizeof vfp );
    printf ( "Test 4: %u %u\n", sizeof *(double *)vf, sizeof *(double *)vfp );
    printf ( "Test 5: %u %u\n\n", sizeof *(float *)vf, sizeof *(float *)vfp );

    printf ( "Test 6: %u %u\n", sizeof c, sizeof *cp );
    printf ( "Test 7: %u %u\n", sizeof c, sizeof cp );
    printf ( "Test 8: %u %u\n", sizeof *(char *)vc, sizeof *(char *)vcp );
    printf ( "Test 9: %u %u\n", sizeof *(double *)vc, sizeof *(double *)vcp );
    printf ( "Test 10: %u %u\n", sizeof *(char *)vc, sizeof *(char *)vcp );

    free ( fp );
    free ( cp );
  }
  return 0;
}

-Prelude

I think this fits in with the general rule

if you have something like

double *d;
sizeof ( (char *) d ) will be the same as sizeof( char *)
because (char *) d considered as a rvalue is of type "char *",

and similarly
sizeof( ( * ( (char *) d) ) ) would be 1
as *( (char *) d ) is of type char considered as a rvalue

another point , I think in C89 the only portable way of printing sizeof is using %lu and casting the sizeof to (unsigned long)
The reason being that the result of sizeof is of type size_t , the only thing that is told about size_t is that it is an unsigned integral type , and since in C89 long is the largest integral type , there should be no problem with this .

printf( "sizeof(a)=%lu", (unsigned long) sizeof(a) ) ;
in C99 one can use %zd and no ugly casts required .

The only behavior of sizeof which might confuse some newbies is that if we have the declaration
char a[20];
then sizeof( a) will be 20 which most probably will be different from sizeof( (char *) ) , even here the general rule is not broken as a is not of type char * , but of type char [20]

and sizeof(char [20] ) is defined to be 20*sizeof(char) = 20

Originally posted by pinko_liberal
Why do you misrepresent what I wrote ?

First off, I don't see you posting anything here. On that, I'll assume that you were "unregistered".

I didn't "misrepresent" what you wrote. I misread it, or at the time wasn't clear on what you were trying to get across.

My reply was not some personal attack on unknown. I was trying to clarify the issue.

You'll see how I could have possibly misunderstood your point, when your sentences come out like:

It does not do so because sizeof is not supposed to do so.

Case and point. This is not only an awkward statement, it's also untrue. Or rather, again it can be misinterpreted.

'sizeof' is supposed to return the size of anything passed to it. If you pass it a pointer, it returns the size of the pointer. If you pass an object, it returns the size of the object. That is all, nothing more.

What I was trying to clarify is that exact line of thought. And for the record, there is a type of 'void'. You just cannot create instances of it. If there weren't 'void', how could you use it as return values and parameters?

Quzah.

I want to say that all of you guys are really helpful and great. Thanx for sharing your ideas
and knowledge. I encourage you to debate in respect one another, but no intend for raising
a STAR WAR!
Back to the question I posted, can you guys show
how to access and dereference a VOID pointer?
No one has illustrate this point clearly so far!

void *vptr;
int a = 5;
int b;
vptr = &a;
printf("vprt is %d", *vprt); /Error, can't dereference a void pointer*/

b = *( (int*)vptr );
*vptr = 10; /*Error too, can't assign env vptr now is point to INT */

Kinda confuse!
DV007