Question

is it possible to wrap a c++ library into c?

how could i do this?

are there any existing tools?

(need to get access to a existing c++ library but only with C)

Answer 1

You can write object-oriented code in C, so if it’s an object-oriented C++ library, it’s possible to wrap it in a C interface. However, doing so can be very tedious, especially if you need to support inheritance, virtual functions and such stuff.

If the C++ library employs Generic Programming (templates), it might get really hairy (you’d need to provide all needed instances of a template) and quickly approaches the point where it’s just not worth doing it.

Assuming it’s OO, here’s a basic sketch of how you can do OO in C:

C++ class:

class cpp {
  public:
    cpp(int i);
    void f();
};

C interface:

#ifdef __cplusplus
extern "C" {
#endif
  typedef void* c_handle;

  c_handle c_create(int i)
  {
    return new cpp(i);
  }

  void c_f(c_handle hdl)
  {
    static_cast<cpp*>(hdl)->f();
  }

  void c_destroy(c_handle hdl)
  {
    delete static_cast<cpp*>(hdl);
  }
#ifdef __cplusplus
}
#endif

Depending on your requirements, you could amend that. For example, if this is going to be a public C interface to a private C++ API, handing out real pointers as handles might make it vulnerable. In that case you would hand out handles that are, essentially, integers, store the pointers in a handle-to-pointer map, and replace the cast by a lookup.

Having functions returning strings and other dynamically sized resources can also become quite elaborate. You would need the C caller provide the buffer, but it can’t know the size before-hand. Some APIs (like parts of the WIn32 API) then allow the caller to call such a function with a buffer of the length 0, in which case they return the length of the buffer required. Doing so, however, can make calling through the API horribly inefficient. (If you only know the length of the required buffer after the algorithm executed, it needs to be executed twice.)
One thing I’ve done in the past is to hand out handles (similar to the handle in the above code) to internally stored strings and provide an API to ask for the required buffer size, retrieve the string providing the buffer, and destroy the handle (which deletes the internally stored string).
That’s a real PITA to use, but such is C.