what is typecasting a pointer to the type (void *)p mean?

[Abhishek]

why do I see that in most C programs, pointers in functions are
accepted as:
int func(int i,(void *)p) where p is a pointer or an address which is
passed from the place where it is called. what do you mean by pointing
to a void and why is it done?
Aso, what happens when we typecast a pointer to another type. say for
example int *i=(char *)p;
under different situations? I am kind of confused..can anybody clear
this confusion by clearly explaining to me what actually is happening
out here?
Bye

[Michael Rasmussen]

On Wed, 25 Jan 2006 12:17:23 -0800, Abhishek wrote:

int func(int i,(void *)p) where p is a pointer or an address which is
passed from the place where it is called. what do you mean by pointing to
a void and why is it done? A pointer to a void is a pointer to an unqualified place in memory. If you
want to work with threads this is unavoidable. One of the reasons is a
way of transfering data from one process to another. You cannot do this
and at the same time preserve the type information. This also means that
the receiving process must know how to dereference the pointer - cast it
to a known type.

#include <stdio.h>
#include <pthread.h>
#include <unistd.h>

void test_p(void *t)
{
int i;
char *text = (char *) t;
for (i = 0; i < 10; ++i)
printf("%s\n", text);
pthread_exit(NU LL);
}

int main()
{
pthread_t t1 = 0;
char *text = "test";

printf("Howdy world!\n");
pthread_create( &t1, NULL, (void *)&test_p, (void *) text);
pthread_join(t1 , NULL);
return 0;
}
Aso, what happens when we typecast a pointer to another type. say for example int *i=(char *)p;

This is dangerous since you could loose information an depending on your
compiler could course either a warning or an error.
--
Hilsen/Regards
Michael Rasmussen
http://keyserver.veridis.com:11371/p...rch=0xE3E80917

[Scorpio]

Abhishek wrote:

why do I see that in most C programs, pointers in functions are
accepted as:
int func(int i,(void *)p) where p is a pointer or an address which is
passed from the place where it is called. what do you mean by pointing
to a void and why is it done?
void pointer is a generic pointer, meaning that it can be used to store
address of any data type.

by (void*)p you are casting the address of p to void* type.
This is actually redundant. Typecasting is not necessary
while assigning value to a void* pointer.
Aso, what happens when we typecast a pointer to another type. say for
example int *i=(char *)p;
This should not even compile because you're trying to assign a wrong
type
of address to int *i.
under different situations? I am kind of confused..can anybody clear
this confusion by clearly explaining to me what actually is happening
out here?
Bye

Sharath A.V

[Abhishek]

Does this alsomean that I get the following flexibility?

like I can use the test_p function to accept different types of
pointers by typecasting them to type void * and later perform an action
depending on a particular flag variable I pass to the function?
like void test_p(void *t, int i)
{
int k;
if(i==1)
{
char *text = (char *) t;
for (k = 0; k < 10; ++k)
printf("%s\n", text);
}
else
{
int *j=(int *)t;
for(k=0;k<10;k+ +)
printf("%d\n",* j);
}

}

here...dependin g upon the value of 'i' I pass, I can take appropriate
action. However, I know that if I pass i=1, then I pass a pointer to a
string by typecasting to void * and if I pass i !=2 then I pass a
pointer to an integer by type casting the integer pointer to type void
*???
Pls clarify

Michael Rasmussen wrote:

On Wed, 25 Jan 2006 12:17:23 -0800, Abhishek wrote:

int func(int i,(void *)p) where p is a pointer or an address which is
passed from the place where it is called. what do you mean by pointing to
a void and why is it done?

A pointer to a void is a pointer to an unqualified place in memory. If you
want to work with threads this is unavoidable. One of the reasons is a
way of transfering data from one process to another. You cannot do this
and at the same time preserve the type information. This also means that
the receiving process must know how to dereference the pointer - cast it
to a known type.

#include <stdio.h>
#include <pthread.h>
#include <unistd.h>

void test_p(void *t)
{
int i;
char *text = (char *) t;
for (i = 0; i < 10; ++i)
printf("%s\n", text);
pthread_exit(NU LL);
}

int main()
{
pthread_t t1 = 0;
char *text = "test";

printf("Howdy world!\n");
pthread_create( &t1, NULL, (void *)&test_p, (void *) text);
pthread_join(t1 , NULL);
return 0;
}

Aso, what happens when we typecast a pointer to another type. say

for

example int *i=(char *)p;

This is dangerous since you could loose information an depending on your
compiler could course either a warning or an error.
--
Hilsen/Regards
Michael Rasmussen
http://keyserver.veridis.com:11371/p...rch=0xE3E80917

[Emmanuel Delahaye]

Abhishek a écrit :

Does this alsomean that I get the following flexibility?
'flexibility' and 'void*' are often associated. Your intuition is correct.
like I can use the test_p function to accept different types of
pointers by typecasting them to type void * and later perform an action
depending on a particular flag variable I pass to the function?
Somehow, yes. Note that the conversion from/to void* doesn't need an
explicit typecast.
like void test_p(void *t, int i)
{
int k;
if(i==1)
{
char *text = (char *) t;
char *text = t;
if (text != NULL)
{ for (k = 0; k < 10; ++k)
printf("%s\n", text); } }
else
{
int *j=(int *)t;
int *j = t;
if (j != NULL)
{
for(k=0;k<10;k+ +)
printf("%d\n",* j); } }

}

here...dependin g upon the value of 'i' I pass, I can take appropriate
action.

Correct.

--
A+

Emmanuel Delahaye

[Michael Rasmussen]

On Wed, 25 Jan 2006 13:01:56 -0800, Abhishek wrote:

Does this alsomean that I get the following flexibility?

like I can use the test_p function to accept different types of pointers
by typecasting them to type void * and later perform an action depending
on a particular flag variable I pass to the function? like void
test_p(void *t, int i)

For this kind of problem I would recommend using a struct.

#include <stdio.h>

enum Kind {integer, string};

struct container {
enum Kind kind;
void *ptr;
};

void test_p(void *data)
{
struct container *c = (struct container *) data;
switch (c->kind) {
case integer:
printf("Receive d integer:\t%d\n" , (int) c->ptr);
break;
case string:
printf("Receive d string:\t%s\n", (char *) c->ptr);
break;
default:
printf("Undefin ed data type\n");
}
}

int main()
{
struct container c;
char *text = "test";
int i = 1;

c.kind = string;
c.ptr = (void *)text;
test_p((void *) &c);
c.kind = integer;
c.ptr = (void *)i;
test_p((void *) &c);
return 0;
}

--
Hilsen/Regards
Michael Rasmussen
http://keyserver.veridis.com:11371/p...rch=0xE3E80917

[Michael Rasmussen]

On Wed, 25 Jan 2006 22:56:57 +0100, Emmanuel Delahaye wrote:

Somehow, yes. Note that the conversion from/to void* doesn't need an
explicit typecast.

Well, not always but in this situation it is mandatory:
void foo(void *t) {
printf("%s", (char *) t);
}

int main() {
char *t = "test";
foo(t);
return 0;
}

So might as well use explicit casting since it is a lot more readable for
an outsider which later has to maintain the code. IMHO

--
Hilsen/Regards
Michael Rasmussen
http://keyserver.veridis.com:11371/p...rch=0xE3E80917

[Al Balmer]

On Wed, 25 Jan 2006 23:07:54 +0100, Michael Rasmussen <mi*@miras.or g>
wrote:

On Wed, 25 Jan 2006 22:56:57 +0100, Emmanuel Delahaye wrote:

Somehow, yes. Note that the conversion from/to void* doesn't need an
explicit typecast.

Well, not always but in this situation it is mandatory:
void foo(void *t) {
printf("%s", (char *) t);
}

int main() {
char *t = "test";
foo(t);
return 0;
}

So might as well use explicit casting since it is a lot more readable for
an outsider which later has to maintain the code. IMHO

void foo(void *t) {
char *rt = t;
printf("%s", rt);
}

--
Al Balmer
Sun City, AZ

[Abhishek]

Thank you all for that wonderful explanation.
So, whats the difference between a null pointer and a pointer which is
pointing to void?
Are these same?

Michael Rasmussen wrote:

On Wed, 25 Jan 2006 22:56:57 +0100, Emmanuel Delahaye wrote:

Somehow, yes. Note that the conversion from/to void* doesn't need an
explicit typecast.

Well, not always but in this situation it is mandatory:
void foo(void *t) {
printf("%s", (char *) t);
}

int main() {
char *t = "test";
foo(t);
return 0;
}

So might as well use explicit casting since it is a lot more readable for
an outsider which later has to maintain the code. IMHO

--
Hilsen/Regards
Michael Rasmussen
http://keyserver.veridis.com:11371/p...rch=0xE3E80917

[Michael Rasmussen]

On Wed, 25 Jan 2006 14:18:42 -0800, Abhishek wrote:

Thank you all for that wonderful explanation. So, whats the difference
between a null pointer and a pointer which is pointing to void?
Are these same?

A null pointer points to nothing - eg. you have a pointer of some type
which has not jet been assigned any value. A pointer to void is a pointer
of some unknown type assigned an address in memory.

--
Hilsen/Regards
Michael Rasmussen
http://keyserver.veridis.com:11371/p...rch=0xE3E80917