Call C++ from C

[flaxyz]

Hello,
how can I call this C++ Code from C ?

class Shape {
public:
  Shape() {
    nshapes++;
  }
  virtual ~Shape() {
    nshapes--;
  };
  double  x, y;   
  void    move(double dx, double dy);
  virtual double area(void) = 0;
  virtual double perimeter(void) = 0;
  static  int nshapes;
};

class Circle : public Shape {
private:
  double radius;
public:
  Circle(double r) : radius(r) { };
  virtual double area(void);
  virtual double perimeter(void);
};

class Square : public Shape {
private:
  double width;
public:
  Square(double w) : width(w) { };
  virtual double area(void);
  virtual double perimeter(void);
};

#include "example.h"
#define M_PI 3.14159265358979323846

/* Move the shape to a new location */
void Shape::move(double dx, double dy) {
  x += dx;
  y += dy;
}

int Shape::nshapes = 0;

double Circle::area(void) {
  return M_PI*radius*radius;
}

double Circle::perimeter(void) {
  return 2*M_PI*radius;
}

double Square::area(void) {
  return width*width;
}

double Square::perimeter(void) {
  return 4*width;
}

Best regards

[zacs7]

You're going to need a C++ compiler anyway, so why not just use C++? You don't have to use C++ bits in the other parts of your code.

[flaxyz]

Unfortunately Ruby-ffi unsderstand only C and not C++, therefore I try to understand how I can reuse C++ code.

[Salem]

http://www.parashift.com/c++-faq-lit...c-and-cpp.html
You could well be stuck then.

So long as you don't have any issues pointed out by the above, then you can do this to invoke a C++ member function from a C call. It's basically the same method used for passing class instances to threads say.

#include <iostream>
#include <cmath>
using namespace std;

class foo {
    public:
        foo(){a=42;}
        static void cToCPlusPlus(void *p);
        void doit ( void );
    private:
        int a;
};
void foo::cToCPlusPlus ( void *p ) {
    foo *magic = reinterpret_cast<foo*>(p);
    magic->doit();
}
void foo::doit( void ) {
    cout << "The answer is " << a << endl;
}

extern "C" {
// This gets
// - A pointer to a class member function, declared static
// - A pointer to an instance of the class
void myCFunc ( void (*fn)(void*), void *instance ) {
    fn(instance);
}
}

int main ( ) {
    foo justMe;
    justMe.doit();
    myCFunc( (void(*)(void*))(foo::cToCPlusPlus), &justMe );
    return 0;
}

[matsp]

Aside from what Salem correctly describes, you can use simple pointers to describe a C++ object, so you don't NEED to use a class member function for this work:

void foo::cToCPlusPlus ( void *p ) {
    foo *magic = reinterpret_cast<foo*>(p);
    magic->doit();
}

You could do it this way:

extern "C" {
// This gets
// - A pointer to a class member function, declared static
// - A pointer to an instance of the class
void myCFunc ( void *instance ) {
    foo *magic = reinterpret_cast<foo*>(instance);
    magic->doit();
}
}

--
Mats

[Elysia]

But the object would have to be created first and the constructor invoked. And you'd probably have to call the destructor manually, too.

[QuantumPete]

But the object would have to be created first and the constructor invoked. And you'd probably have to call the destructor manually, too.

That's why you normally have a wrapper file, with functions that wrap each operation you'd do on the object, including a construction function, which will construct the object, cast it to a void* and return it.
It's far from ideal, but if you need a smallish C++ class from C code, this is good way of doing it.

QuantumPete

[matsp]

That's why you normally have a wrapper file, with functions that wrap each operation you'd do on the object, including a construction function, which will construct the object, cast it to a void* and return it.
It's far from ideal, but if you need a smallish C++ class from C code, this is good way of doing it.

QuantumPete

Yes, we have some rather large third party code in C that needs to interface to our overall C++ OS code, and it maintains the objects through storing them as void pointers for the C code, and then calling out to a wrapper layer that casts the void pointer back to a C++ object and does whatever is necessary to the object. This includes, of course, functions to create and destroy the objects as needed.

--
Mats

[flaxyz]

@matsp: Do you know where can I find examples of your c wrapper?

@Salem: how can I compile your code?

[Salem]

How?
How is use a C++ compiler.
You're going to have to compile your C++ code with a C++ compiler.

[matsp]

@matsp: Do you know where can I find examples of your c wrapper?

Sure, if you work for a large mobile phone company (or, I suppose any other company that wishes to enter into a license agreement), you can license the OS from us. But unfortunately, it's not available as sample code anywhere.

However, the principle is as I described above, in C++ code with extern "C", call a C++ function. To store object pointers in C use a void *, and when it's needs to be used again in C++ code, cast the void pointer into an object pointer with reinterpret_cast.

--
Mats