Usually, books usually discourage the use of conversion operators when wrapping up c structs. For example the c++ string, which is (believed to be) a wrapper of a C char array, does not provide a conversion operator. Instead it gives the the method `c_str()`. 

However, I seriously think my case may be an exception. I am wrapping up an `SDL_Surface.` Here's the class declaration.

```
/** Wraps up SDL_Surface **/
class surface
{
    SDL_Surface* _surf;
public:
    /** calls SDL_LockSurface().
     ** throws surface_lock_exception on failure.
     **/
    void lock();

    /** calls SDL_UnlockSurface() **/
    void unlock();

    /** calls SDL_LoadBMP().
     ** throws image_load_exception on failure.
     **/
    void load_bmp(const string&);

    /** calls SDL_FreeSurface(). **/
    void free();

    /** destructor. Also free()s the internal SDL_Surface. **/
    ~surface();
};

```

In this case, I seriously think I should add a conversion operator to `SDL_Surface*` for easy compatibility with other SDL Functions that require an `SDL_Surface*`.

What do you think:

1. Would a conversion operator be prudent?
2. Or Should I use a method like `c_str()`?
3. Or is there another, better solution?