从C ++到C的转换

Question

Hi I am interested by converting some code from C++ to C (mostly because i need to use the library with/from other C program and other language) . C is a better gateway for that I am interested to replicate few C++ concept like inheritance for inst .

Does anyone know good references or has already work on some similar issues. For inst how to deal with inheritance , adding new members variable/ methods to child class , ...

Thx for your help

Answer 1

if you need to call the lib from C, i would design a clean C API that internally calls the C++ functions. The linkage is different between C and C++ , so, you must specify:

#ifdef __cplusplus
extern "C" { 
#endif

void my_c_function (void );

#ifdef __cplusplus
}
#endif

About desing, you must hide classes , templates, etc. I suggest you to read some C libraries, like libpng or OpenGL 1.0, to get an idea of a pure C interface.

In C , you must construct and delete "objects" by yourself. You can use some kind of object oriented programming if you pass the "this" pointer for your "objects" in each call.

But unfortunately, you will have something like "void pointers". You can use handles (like win32) if you dont want to expose your internal memory.

Answer 2

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.