This header only library helps you use C api in a shared library by dynamically loading instead of linking to it with minimal efforts.
Here is a simple zlib example, if you want use zlib functions, inherits class zlib::api.
define a class with zlib functions in zlib_api.h
#ifndef CAPI_LINK_ZLIB
namespace zlib { //need a unique namespace
namespace capi {
#else
extern "C" {
#endif
#include "zlib.h" //// we need some types define there. otherwise we can remove this
#ifndef CAPI_LINK_ZLIB
}
#endif
}
namespace zlib { //need a unique namespace
#ifndef CAPI_LINK_ZLIB
using namespace capi;
#endif
class api_dll; //must use this name
class api //must use this name
{
api_dll *dll;
public:
api();
virtual ~api();
virtual bool loaded() const;
#if !defined(CAPI_LINK_ZLIB) && !defined(ZLIB_CAPI_NS)
const char* zlibVersion();
const char* zError(int);
#endif
};
} //namespace zlib
#ifdef ASS_CAPI_NS
using namespace zlib::capi;
#else
using namespace zlib;
#endif
zlib_api.h is the header you will use
zlib_api.cpp (some code can be generated from tools/mkapi)
#define DEBUG //log dll load and symbol resolve
//#define CAPI_IS_LAZY_RESOLVE 0 //define it will resolve all symbols in constructor
#include <QtCore/QLibrary> // need a library loader/resolver class whose function names like QLibrary
#include "capi.h"
#include "zlib_api.h" //include last because zlib.h was in namespace capi to avoid covering types later
namespace zlib {
static const char* zlib[] = {
#if defined(WIN32) || defined(_WIN32) || defined(__WIN32__) || defined(__NT__) || defined(WIN64) || defined(_WIN64) || defined(__WIN64__)
"zlib",
#else
"z",
#endif
NULL
};
static const int versions[] = { ::capi::NoVersion, 1, 0, ::capi::EndVersion };
//CAPI_BEGIN_DLL(zlib, QLibrary)
CAPI_BEGIN_DLL_VER(zlib, versions, QLibrary)
CAPI_DEFINE_ENTRY(const char*, zlibVersion, CAPI_ARG0())
CAPI_DEFINE_ENTRY(const char*, zError, CAPI_ARG1(int))
CAPI_END_DLL()
CAPI_DEFINE_DLL
CAPI_DEFINE(const char*, zlibVersion, CAPI_ARG0())
CAPI_DEFINE(const char*, zError, CAPI_ARG1(int))
} //namespace zlib
test.cpp (dynamically loaded symbols, not link to zlib):
//#define ZLIB_CAPI_NS // namespace style
//#define CAPI_LINK_ZLIB // direct linkt to zlib. add -lz is required
#include <stdio.h>
#include "zlib_api.h"
class test_zlib_api
#ifndef ZLIB_CAPI_NS
: public zlib::api // will unload library in dtor
#endif
{
public:
void test_version() {
printf("zlib version: %s\n", zlibVersion());
}
void test_zError(int e) {
printf("zlib error: %d => %s\n", e, zError(e));
}
};
int main(int, char **)
{
test_zlib_api tt;
printf("capi zlib test\n");
tt.test_version();
tt.test_version();
tt.test_zError(1);
return 0;
}
The same code support 3 styles with only 1 line change in you code (test.cpp above)! You can switch class style and namespace without rebuild api implementation object(zlib_api.cpp).
-
Class style(the default)
All the functions you call are from class
zlib:apiand your class must be a subclass of it. -
Namespace style
All the functions you call are from namesoace
zlib:capi. Must add#define ZLIB_CAPI_NSbefore#include "zlib_api.h".It's easier to use than class style. It is not the default style because if the library is loaded and unloaded multiple times, symbol addresses from first load(wrong!) are used in current implementation.
-
Direct link style
The original functions are called. Must add
#define CAPI_LINK_ZLIBbefore#include "zlib_api.h", add-DCAPI_LINK_ZLIBto rebuild zlib_api.cpp add-lzflags to the compiler
The symbol is resolved at the first call. You can add #define CAPI_IS_LAZY_RESOLVE 0 in zlib_api.cpp before #include "capi.h" to resolve all symbols as soon as the library is loaded.
There is a tool to help you generate header and source: https://github.com/wang-bin/mkapi
The tool is based on clang 3.4.
Run make to build the tool then run ./mkapi.sh -name zlib zlib.h -I to generate zlib_api.h and zlib_api.cpp.