Develop a set of C APIs that will wrap around our existing C++ APIs to access our core logic (written in object-oriented C++). This will essentially be a glue API that allows our C++ logic to be usable by other languages. We based this development on a specific design pattern called hourglass pattern. All we ended up doing was: Every object is passed about in C an opaque handle. Constructors and destructors are wrapped in pure functions Member functions are pure functions. Other built-ins are mapped to C equivalents where possible.<\/p>\n
So a class like this (C++ header)<\/p>\n
class MyClass {\r\n\r\npublic:\r\n\r\nexplicit MyClass( std::string & s );\r\n\r\n~MyClass(); int doSomething( int j );\r\n\r\n}<\/pre>\nWould map to a C interface like this (C header):<\/p>\n
struct HMyClass; \/\/ An opaque type that we'll use as a handle\r\n typedef struct HMyClass HMyClass;\r\n HMyClass * myStruct_create( const char * s );\r\n void myStruct_destroy( HMyClass * v );\r\n int myStruct_doSomething( HMyClass * v, int i );<\/pre>\nThe implementation of the interface would look like this (C++ source)<\/p>\n
#include \"MyClass.h\"\r\n extern \"C\" {\r\n HMyClass * myStruct_create( const char * s ) {\r\n return reinterpret_cast<HMyClass*>( new MyClass( s ) );\r\n }\r\n void myStruct_destroy( HMyClass * v ) {\r\n delete reinterpret_cast<HMyClass*>(v);\r\n }\r\n int myStruct_doSomething( HMyClass * v, int i ) {\r\n return reinterpret_cast<HMyClass*>(v)->doSomething(i);\r\n }\r\n }<\/pre>\n
#ifdef __cplusplus\r\n extern \"C\"\r\n {\r\n #endif\r\n void * myStruct_create( const char * s );\r\n void myStruct_destroy( void * v );\r\n int myStruct_doSomething( void * v, int i );\r\n #ifdef __cplusplus\r\n }\r\n #endif<\/pre>\nAnd your wrapper\u2019s .cpp file will look like this:<\/p>\n
void * myStruct_create( const char * s ) {\r\n MyStruct * ms = NULL;\r\n try { \/* The constructor for std::string may throw *\/\r\n ms = new MyStruct(s);\r\n } catch (...) {}\r\n return static_cast<void*>( ms );\r\n }<\/pre>\nvoid myStruct_destroy( void * v ) {\r\n MyStruct * ms = static_cast<MyStruct*>(v);\r\n delete ms;\r\n}\r\nint myStruct_doSomething( void * v, int i ) {\r\n MyStruct * ms = static_cast<MyStruct*>(v);\r\n int ret_value = -1; \/* Assuming that a negative value means error *\/\r\n try {\r\n ret_value = ms->doSomething(i);\r\n } catch (...) {}\r\n return ret_value;\r\n }\r\n}<\/pre>\nEven better: If you know that all you need as a single instance of MyStruct, don\u2019t take the risk of
\ndealing with void pointers being passed to your API. Do something like this instead:<\/p>\n
\r\n static MyStruct * _ms = NULL;\r\n int myStruct_create( const char * s ) {\r\n int ret_value = -1; \/* error *\/\r\n try { \/* The constructor for std::string may throw *\/\r\n _ms = new MyStruct(s);\r\n ret_value = 0; \/* success *\/\r\n } catch (...) {}\r\n return ret_value;\r\n }\r\n void myStruct_destroy() {\r\n if (_ms != NULL) {\r\n delete _ms;\r\n }\r\n }\r\n int myStruct_doSomething( int i ) {\r\n int ret_value = -1; \/* Assuming that a negative value means error *\/\r\n if (_ms != NULL) {\r\n try {\r\n ret_value = _ms->doSomething(i);\r\n } catch (...) {}\r\n }\r\n return ret_value;\r\n }<\/pre>\nOTHER POINTS<\/h2>\n
Namespace should be replaced by a prefix for each function.
\nTo be continued\u2026<\/p>\n