wrap a c++ library in c? (don't “extern c”)

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 on

Answer 1

Wrap it in C++ cpp that calls that dll, and "extern C" in that file you made.

Answer 2

Write a c++ wrapper that does an extern c, compile that with c++, and call your wrapper.

Answer 3

If the C++ library is written which can be compiled with C compiler with slight editting (such as changing bool to int, false to 0 and true to 1 etc), then that can be done.

But not all C++ code can be wrapped in C. Template is one feature in C++ that cannot be wrapped, or its nearly impossible.

Answer 4

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.

Answer 5

(don't “extern c”)

extern C only helps you to have a names in dll like you see them.

You can use
dumpbin /EXPORTS your.dll
to see what happens with names with extern C or without it.
http://msdn.microsoft.com/en-us/library/c1h23y6c(v=vs.71).aspx

To answer your question... It depends... But it is highly unlikely that you can use it without wrappings. If this C++ library uses just a simple functions and types you can just use it. If this C++ library uses a complex classes structure - probably you will be unable to use it from C without wrapping. It is because the internal of classes may be structured one way or another depending on many conditions (using inference with virtual tables or abstracting. Or in example complex C++ library may have its own object creation mechanisms so you HAVE to use it in the way it is designed or you will get unpredictable behavior).

So, I think, you have to prepare yourself for doing dome wrappings.

And here is a good article about wrapping C++ classes. It the article the Author tells about wrapping C++ classes to C# but he uses C at first step.
http://www.codeproject.com/KB/cs/marshalCPPclass.aspx