What is the (void *arg)? How does it work, and how would I access the data of a void type?
What is the (void *arg)? How does it work, and how would I access the data of a void type?
it is just a general pointer passing to the function, your function should know what is the actual type of the pointer - and cast it apropriatly before accessing the data.
It is mostly used in the Callbacks, when library is provided with CB address and some context address.
Library does not need to know the type of the data - so the pointer is stored as void* and supplied to the CB, when it is called from the library code
the CB - which is part of the application code - knows exactly what is the data type passed as a context and could cast the pointer accordingly
Last edited by vart; 03-17-2009 at 12:23 PM.
All problems in computer science can be solved by another level of indirection,
except for the problem of too many layers of indirection.
– David J. Wheeler
Thanks, I understand know.
This technique isn't used as often in C++ as it is in C, but there are certain situations where it's unavoidable. A typical usage is with callback functions. Lets say you have a shape-drawing library. You want to allow the user to decide what to do when a pixel needs to be drawn. You have no idea what data structures the client code requires to accomplish that so you simply have them pass a pointer to their data. Here's a somewhat contrived example:
Code:// library code typedef void ( * callback )( int, int, void* ); void draw_some_shape( rectangle* bounds, callback function, void* data ) { for( int r = bounds->top; r < bounds->bottom; ++r ) for( int c = bounds->left; c < bounds->right; ++c ) if( inside( r, c ) ) callback( r, c, data ); } // client code struct image_data { int image[ HEIGHT ][ WIDTH ], color; }; void draw_pixel( int row, int column, void* data ) { image_data* image = ( image_data* )data; image_data->image[ row ][ column ] = image_data->color; } int main( void ) { image_data data; data.color = hsv( 0.333, 0.5, 0.5 ); rectangle bounds; bounds.top = HEIGHT / 2; bounds.left = WIDTH / 2; bounds.bottom = HEIGHT; bounds.right = WIDTH; draw_some_shape( &bounds, draw_pixel, &data ); // do something useful with the image return 0; }
Last edited by Sebastiani; 03-17-2009 at 12:41 PM. Reason: corrections
Code:#include <cmath> #include <complex> bool euler_flip(bool value) { return std::pow ( std::complex<float>(std::exp(1.0)), std::complex<float>(0, 1) * std::complex<float>(std::atan(1.0) *(1 << (value + 2))) ).real() < 0; }
That said, this is one situation where it is avoidable in C++ by means of C++ templates, e.g.,Originally Posted by Sebastiani
Code:// library code template<typename T, typename Callback> void draw_some_shape( const rectangle& bounds, Callback function, T& data ) { for( int r = bounds.top; r < bounds.bottom; ++r ) for( int c = bounds.left; c < bounds.right; ++c ) if( inside( r, c ) ) function( r, c, data ); } // client code struct image_data { int image[ HEIGHT ][ WIDTH ], color; }; void draw_pixel( int row, int column, image_data& data ) { image_data.image[ row ][ column ] = image_data.color; } int main( void ) { image_data data; data.color = hsv( 0.333, 0.5, 0.5 ); rectangle bounds; bounds.top = HEIGHT / 2; bounds.left = WIDTH / 2; bounds.bottom = HEIGHT; bounds.right = WIDTH; draw_some_shape( bounds, draw_pixel, data ); // do something useful with the image return 0; }
Look up a C++ Reference and learn How To Ask Questions The Smart WayOriginally Posted by Bjarne Stroustrup (2000-10-14)
This can be avoided with template, as shown below:
There is little excuse for void* in C++, except for calling C functions.Code:// library code template<typename T, typename Callback_t> void draw_some_shape( rectangle* bounds, Callback_t function, T& data ) { for( int r = bounds->top; r < bounds->bottom; ++r ) for( int c = bounds->left; c < bounds->right; ++c ) if( inside( r, c ) ) callback( r, c, data ); } // client code struct image_data { int image[ HEIGHT ][ WIDTH ], color; }; void draw_pixel( int row, int column, image_data* data ) { image_data->data[ row ][ column ] = image_data->color; } int main() { image_data data; data.color = hsv( 0.333, 0.5, 0.5 ); rectangle bounds; bounds.top = HEIGHT / 2; bounds.left = WIDTH / 2; bounds.bottom = HEIGHT; bounds.right = WIDTH; draw_some_shape( &bounds, &draw_pixel, &data ); // do something useful with the image return 0; }
The method you and Laserlight are talking about is definitely a good one, but it still, in theory, allows the possibility for the callback driver to poke around inside the T object when it shouldn't. In practice, this would be extremely difficult because you don't know what's in there, but a void * completely guarantees that the code won't touch it, since it has no idea what type it is (even as a template parameter).
Normally though, I'd define a callback API like this:
The actual callback just inherits from Callback and overrides DoIt().Code:class Callback { public: virtual ~Callback() {} virtual void DoIt() = 0; }; void DriveTheCallback(Callback *cb) { cb->DoIt(); }
Code://try //{ if (a) do { f( b); } while(1); else do { f(!b); } while(1); //}
Well, I suppose that may be, but then we would get into X vs Y. Your solution might hide the object, but it's also slower due to being dynamic polymorphism as opposed to static polymorphism.
It also means more work, but hey, no solution is ever perfect.