This is an completely rewritten version of an earlier question; I think the first version omitted important details; this one provides all the context.
I have a header of some C++ API. The API declares a few classes like this:
class Foo
{
public:
inline void Bar(void);
/* more inlines */
private:
inline Foo();
/* maybe more inline constructors */
}
I.e. no members, all functions are inline and public, except constructors. Constructors are private, so, as far as I understand C++, I cannot really call them. To create these objects I'm supposed to use auto_ptrs to them:
class FooAutoPtr : public std::auto_ptr<Foo>
{
public:
inline FooAutoPtr();
/* one for each Foo constructors */
}
The API also has a second set of functions like this:
void Foo_Bar(void *self);
Foo* Foo_Constructor();
Let's call them core functions, because these are the symbols actually exported from the host app. Not the C++ classes.
Core functions have C linkage (i.e. they declared as extern "C"), but they are declared as taking and returning C++ types (e.g. they can take a reference: Foo &foo). Finally the header contains the implementation of the inline functions of the C++ classes. All these functions do the same: they call the core functions. For example, the FooAutoPtr constructor is like this:
inline FooAutoPtr::FooAutoPtr()
{
reset(Foo_Constructor());
}
From what I understand, the code receives some object that is supposed to be a pointer to Foo from the host app and changes the auto_ptr gizmo to point to this object. But to the developer it looks as if it was a true pointer to Foo. And calling Foo::Bar() goes like this:
inline Foo::Bar()
{
Foo_Bar(this);
}
This goes for all C++ classes and methods. Clever, huh?
Now, could somebody please explain what does all this mean? :) It's not a true C++ API, is it? To me it looks more like a thin C++ wrapper on top of a C API. If so, can I redeclare the core functions to lose the C++ bits? I understand how to write a C wrapper around C++ (actually, I already wrote it), but, if possible, I'd rather lose the wrapper and use the functions directly. But how do I lose the C++ stuff?
For example, there could be a function with references:
Bar& Foo_GetBar(void* self, const Baz& baz, int& i);
Right now I call it from my C++ wrapper like this:
typedef struct bar bar_t; /* and others */
/*...*/
bar_t*
foo_get_bar(foo_t* foo, baz_t* baz, int* i)
{
return (bar_t*) &Foo_GetBar(foo, *(Baz*)baz, *i);
}
and it works (I have no idea, how). But I'd rather have it redeclared like this:
/* type? */ Foo_GetBar(foo_t*, /* type? /*, /* type? */);
UPDATE: I found an interesting thing that confirms Neil's answer. It is code in Common Lisp that uses the same API. (Naturally, it has to use the C part.) And, from what I can (barely) read in the source, the author simply used pointers in place of of references. Here's a snippet from code that converts C++ declarations into Lisp:
;; use * instead of & - we're not interested in C++ details
line (regex-replace-all "&" line "*")
So that's it :) Thanks, everyone!
