博客

Sample如下：

Here’s a quick example of how you might go about wrapping a C++ class or API in a C-callable API that does little more than forward the C calls to the C++ object.

Suppose you have a C++ library with the following interface:

class stopwatch
{
public:
    void start();
    void stop();
    void reset();

    unsigned int get_elapsed();

private:
    // whatever...
};

Your C API might have a interface that’s described by the following header:

#ifndef STOPWATCH_API_H
#define STOPWATCH_API_H

#if __cplusplus
extern "C" {
#endif


struct stopwatch_handle;

stopwatch_handle* stopwatch_create(void);
void stopwatch_delete( struct stopwatch_handle*);

void stopwatch_start(struct stopwatch_handle*);
void stopwatch_stop(struct stopwatch_handle*);
void stopwatch_reset(struct stopwatch_handle*);
void stopwatch_get_elapsed(struct stopwatch_handle*);


#if __cplusplus
}
#endif
#endif

Note that the above header is designed to be included in either C or C++ modules, and the appropriate parts are marked as being

extern "C"

when compiled in a C++ module.

Now the implementation of that C API is done in a .cpp module so it can access the C++ library, but it presents the C-callable interface.

#include <new>  // for nothrow new
#include "stopwatch.h"  // the C++ library API
#include "stopwatch_api.h"  // the C callable interface that's being
                            //   implemented here

struct stopwatch_handle {
    stopwatch impl;   // the C code never needs to know about this
                      // internal part of the struct, since all that
                      // the C client code will deal with is an
                      // opaque pointer
};


extern "C"
stopwatch_handle* stopwatch_create(void)
{
    // use nothrow new since it doesn't make sense to 
    // have an exception bubble up to C code
    return new(std::nothrow) stopwatch_handle;
}


extern "C"
void stopwatch_delete( struct stopwatch_handle* p)
{
    delete p;
}


extern "C"
void stopwatch_start(struct stopwatch_handle* p)
{
    p->impl.start();
}


extern "C"
void stopwatch_stop(struct stopwatch_handle* p);
{
    p->impl.stop();
}


extern "C"
void stopwatch_reset(struct stopwatch_handle* p)
{
    p->impl.reset();
}


extern "C"
unsigned int stopwatch_get_elapsed(struct stopwatch_handle* p)
{
    return p->impl.get_elapsed();
}

Note that in the

stopwatch_create()

function we call a variant of operator

new

that won’t throw an exception on failure, since that will often make little sense (unless you expect that the exception should terminate the program or that there will be an appropriate handler further along the stack). This kind if thing might make your C API functions a little more complex if they need to handle possible exceptions and ‘convert’ them to an error handling mechanism that’s appropriate for C.

转发一个中文的帖子：

如何用C语言封装 C++的类，在 C里面使用

如何用C语言封装 C++的类，在 C里面使用_小猪爱拱地-CSDN博客