Which one is the better - calling c++ library from c program? - c++

Question

I have c++ library .so. My co-worker is working on c program which will call c++ library from his c program. I told him to create Wrapper.h and Wrapper.cpp and use pointer for passing around c++ objects in his c program. However, I found that he was trying to modify our c++ library source code by adding Wrapper.cpp and header into our library .so directly. For example:
class A{ SetValueA(int); }
class B{ SetValueB(int); }
In his Wrapper.cpp, he wrote sth like this:
A a;
B b;
extern "C" SetValueA(int) {a.SetValueA(int); }
extern "C" SetValueB(int) {b.SetValueB(int); }
Then he recompiled our c++ library and includes Wrapper.h in his c program.
What I told him is to do sth like this:
In my Wrapper.cpp
extern "C" {
A* newClassA() {
return new A();
}
void SetValueA(A* v, int i) {
v->SetA(i);
}
B* newClassB() {
return new B();
}
void SetValueB(B* v, int i) {
v->SetB(i);
}
void deleteClassA(A* v) {
delete v;
}
void deleteClassB(B* v) {
delete v;
} }
Then I just compiled my Wrapper.cpp and linked with our c++ library. In his c program, he just need to include Wrapper.h and compile his c code, and then compile Wrapper.o and main.o(from main.c) by using c++ compiler.
His solution looks working too, he complained that the way I told him is more works. But I dont want him to change our c++ library coz nobody else will use Wrapper class from c++ library. Can you tell me which one is the better and why?
Yes, I also dont like his way using global variable in his wrapper.

Answer 1

I don't see why there is a need to change any library file to use global variables: the necessary change should b confined to Wrapper.cpp which is clearly part of the wrapper.
That said, I don't believe in the use of any [mutable] global object. They tend to be a problem in many different ways. That is, I'd agree that the proper approach to create a wrapper is to effectively deal with the necessary life-time management. I do realize that getting life-time management properly sorted in C is harder than in C++. The fix to that is to use C++, not to create unnecessary dependencies (I'm aware that this argument typically doesn't fly with C programmers).

Answer 2

The wrapper that your co-worker wrote is of course indiscutable due to the use of global variables, which introduce many issues into your library.
However, I believe, a well written library should export a C interface by itself, even if it uses C++ internally. For the simple reason that a C interface can be imported into virtually every language, while a C++ interface requires user code to be C++. Also, forcing this kind of wrapper into user code is likely to lead to a proliferation of different wrapper.cpp versions, all of which are incomplete and out of date in different ways.
As such, I would include code along the lines of your wrapper.cpp into your library. And I would certainly move it close to the code that it wraps, instead of bundling it all in one big, fat wrapper.cpp. That way it is much easier to check whether all your public methods have been wrapped properly.