Hi Everyone,

There was a discussion on the need of void * in C and C++. In C, it
is a generic pointer which can be typecasted to and from that of other
types.

And it is developer's head ache to take care that the cast to and
from void * is correct. C++ enhanced type cast dynamic_cast doesn't
in this case, as it needs the type information. This makes me
wonder, why make a cast to void * and pass the info to other
functions? Why not simply pass the direct pointer?

Does anyone know the reason where void* only can solve the problem?

Rahul wrote:
> Hi Everyone,
>
> There was a discussion on the need of void * in C and C++. In C, it
> is a generic pointer which can be typecasted to and from that of other
> types.
>
> And it is developer's head ache to take care that the cast to and
> from void * is correct. C++ enhanced type cast dynamic_cast doesn't
> in this case, as it needs the type information. This makes me
> wonder, why make a cast to void * and pass the info to other
> functions? Why not simply pass the direct pointer?
>

In C++, we don't use void* in this case, we use base_class* as
parameter, and we don't have to do explicit cast before passing it.

An good example why using void* in C is thread entry function,
an thread entry function often defined as following:

void entry_fn(void* param) // client programmer
{
// cast param to the exact type and use it
}

CRT function on Win32 to create a thread.

uintptr_t _beginthread(
void( *start_address )( void * ),
unsigned stack_size,
void *arglist
);

// client programmer create a thread like the following

_beginthread(entry_fn, 0, NULL);

entry_fn is also considered as callback function, _beginthread can't
foresee what kind of param, number of params that the client programmer
will use, so leave it to a generic type (void*).


> Does anyone know the reason where void* only can solve the problem?

Rahul wrote:
> Hi Everyone,
>
> There was a discussion on the need of void * in C and C++. In C, it
> is a generic pointer which can be typecasted to and from that of other
> types.
>
> And it is developer's head ache to take care that the cast to and
> from void * is correct. C++ enhanced type cast dynamic_cast doesn't
> in this case, as it needs the type information. This makes me
> wonder, why make a cast to void * and pass the info to other
> functions? Why not simply pass the direct pointer?
>
> Does anyone know the reason where void* only can solve the problem?


In C generic programming is made by using void pointers and id
parameters. In C++ we use templates instead:


For example:

/*C */

void somefunc(void *p, char id)
{
if (id=='i')
/* ... */

if (id== 'n')
/* ... */
}


// C++
void somefunc(T &obj)
{
//...

}

Some corrections:


john wrote:
>
>> Does anyone know the reason where void* only can solve the problem?
>
>
> In C generic programming is made by using void pointers and id
> parameters. In C++ we use templates instead:
>
>
> For example:
>
> /*C */
>
> void somefunc(void *p, char id)
> {
> if (id=='i')
> /* ... */
>
==> else if (id== 'n')
> /* ... */
> }
>
>
> // C++
==> template <class T>
> void somefunc(T &obj)
> {
> //...
>
> }

In article
<e2fdaa19-9566-47b9-a838-7ddaa87c1568@e23g2000prf.googlegroups.com>,
Rahul <sam_cit@yahoo.co.in> wrote:

> Hi Everyone,
>
> There was a discussion on the need of void * in C and C++. In C, it
> is a generic pointer which can be typecasted to and from that of other
> types.
>
> And it is developer's head ache to take care that the cast to and
> from void * is correct. C++ enhanced type cast dynamic_cast doesn't
> in this case, as it needs the type information. This makes me
> wonder, why make a cast to void * and pass the info to other
> functions? Why not simply pass the direct pointer?
>
> Does anyone know the reason where void* only can solve the problem?

As I see it, void* shows the pedigree of C++ as coming from C, a system
programming language.

While implementing very low level routines, there are cases where you
want to deal with a "bucket of bits" that is untyped. For example, the
following endian-reversing routine (inherently compiler- and
platform-dependent) may not care what the type is of the thing you're
reversing:

namespace Compiler_Dependent
{
void reverse_endian(void*, std::size_t size);
}

You can then add your own type-safe wrappers around it:

template <typename T>
inline void reverse_endian(T& item)
{
Compiler_Dependent::reverse_endian(&T, sizeof(T));
}

Other examples include raw-bytes buffer implementations.

-dr

On 2007-12-24 11:14:56 -0600, Dave Rahardja <moc.xobop@ajdrahard.com> said:
>
> template <typename T>
> inline void reverse_endian(T& item)
> {
> Compiler_Dependent::reverse_endian(&T, sizeof(T));
> }

Whoops, reverse_endian(&item... of course.