Developing C wrapper API for Object-Oriented C++ code

by

This is not too hard to do by hand, but will depend on the size of your interface.
The cases where I’ve done it were to enable use of our C++ library from within pure C code, and thus SWIG was not much help. (Well maybe SWIG can be used to do this, but I’m no SWIG guru and it seemed non-trivial)

All we ended up doing was:

  1. Every object is passed about in C an opaque handle.
  2. Constructors and destructors are wrapped in pure functions
  3. Member functions are pure functions.
  4. Other builtins are mapped to C equivalents where possible.

So a class like this (C++ header)

class MyClass
{
  public:
  explicit MyClass( std::string & s );
  ~MyClass();
  int doSomething( int j );
}

Would map to a C interface like this (C header):

struct HMyClass; // An opaque type that we'll use as a handle
typedef struct HMyClass HMyClass;
HMyClass * myStruct_create( const char * s );
void myStruct_destroy( HMyClass * v );
int myStruct_doSomething( HMyClass * v, int i );

The implementation of the interface would look like this (C++ source)

#include "MyClass.h"

extern "C" 
{
  HMyClass * myStruct_create( const char * s )
  {
    return reinterpret_cast<HMyClass*>( new MyClass( s ) );
  }
  void myStruct_destroy( HMyClass * v )
  {
    delete reinterpret_cast<MyClass*>(v);
  }
  int myStruct_doSomething( HMyClass * v, int i )
  {
    return reinterpret_cast<MyClass*>(v)->doSomething(i);
  }
}

We derive our opaque handle from the original class to avoid needing any casting, and (This didn’t seem to work with my current compiler). We have to make the handle a struct as C doesn’t support classes.

So that gives us the basic C interface. If you want a more complete example showing one way that you can integrate exception handling, then you can try my code on github : https://gist.github.com/mikeando/5394166

The fun part is now ensuring that you get all the required C++ libraries linked into you larger library correctly. For gcc (or clang) that means just doing the final link stage using g++.

More Related Contents:

  1. How to use C++ in Go
  2. Is there any LAME C++ wrapper\simplifier (working on Linux Mac and Win from pure code)?
  3. C++ Class wrapper around fundamental types
  4. Wrapping FILE* with custom std::ostream
  5. Using includes with c++ shared libraries
  6. Error while passing vector to instance of object in main
  7. How do I list the symbols in a .so file
  8. How to get the error message from the error code returned by GetLastError()?
  9. Correct use of std::cout.precision() – not printing trailing zeros
  10. Why doesn’t SFINAE (enable_if) work for member functions of a class template?
  11. C++ handling very large integers
  12. connected components in OpenCV
  13. cin input (input is an int) when I input a letter, instead of printing back incorrect once, it prints correct once then inc for the rest of the loop
  14. Is #pragma once part of the C++11 standard?
  15. Why do I need double layer of indirection for macros?
  16. operator= and functions that are not inherited in C++?
  17. how provide a vertex_index property for my graph
  18. Why can’t I create a vector of lambdas (of the same type) in C++11?
  19. How to call derived class method from base class pointer?
  20. When does cout flush?
  21. How to avoid errors in Vscode for putting header files in a separate directory than src
  22. Detect when multiple enum items map to same value
  23. C++11 rvalue reference calling copy constructor too
  24. Convert string with explicit escape sequence into relative character
  25. What is the safe way to fill multidimensional array using std::fill?
  26. Best Tips for documenting code using doxygen? [closed]
  27. How does “using std::swap” enable ADL?
  28. What should the ‘pop()’ method return when the stack is empty? [duplicate]
  29. Loading a dll from a dll?
  30. Why calling main() is not allowed in C++

Leave a Comment