Converting a C++ class to a C struct (and beyond)

Question

Past few days I have been "downgrading" > 1000 filem of C++ code into C. It's been going well until now. Suddenly I'm face to face with a class...

The compiler pointed out the error first in the header file:

class foobar {
    foo mutex;
public:
    foobar() {
        oneCreate(&mutex, NULL);
    }
    ~foobar() {
        oneDestroy(mutex);
        mutex = NULL;
    }
    void ObtainControl() {
        oneAcquire(mutex);
    }
    void ReleaseControl() {
        oneRelease(mutex);
    }
};

And of course, the C file has to take advantage of this

foobar fooey;
fooey.ObtainControl();

I don't even know where to start.... Help?

Isn't OO in C just `ObtainContol(&fooey);`? You an even call the parameter `this`. — Bo Persson, May 03 '11 at 17:01
@Bo But that isn't going to magically simulate RAII, which this class (and presumably others) is using. — , May 03 '11 at 17:04
@unapersson - Right, I focused on the second line of the code sample. The upside is that you don't have any exceptions either, so RAII is less important. "Just" add construct_foobar and destruct_foobar and call them at the right spots. Now remember why I like C++ better! — Bo Persson, May 03 '11 at 17:12
Why would you downgrade from C++ to C? What is the reason behind that decision? — David Rodríguez - dribeas, May 03 '11 at 17:27

score 12 · Accepted Answer · answered May 03 '11 at 17:02

Turn foobar into a normal struct

struct foobar {
    goo mutex;
};

Create your own "constructor" and "destructor" as functions that you call on that struct

void InitFoobar(foobar* foo)
{
   oneCreate(&foo->mutex);
}

void FreeFoobar(foobar* foo)
{
   oneDestroy(foo->mutex);
}

struct foobar fooStruct;
InitFoobar(&fooStruct);
// ..
FreeFoobar(&fooStruct);

etc

score 5 · Answer 2 · edited May 03 '11 at 17:10

5

since C-structs can't have member functions, you can either make function pointers, or create non-member versions of those functions, ex:

struct foobar {
    foo mutex;
};

Construct_foobar(foobar* fooey) {
    oneCreate(&fooey->mutex, NULL);
}
Destroy_foobar(foobar* fooey) {
    oneDestroy(fooey->mutex);
    fooey->mutex = NULL;
}
void ObtainControl(foobar* fooey) {
    oneAcquire(fooey->mutex);
}
void ReleaseControl(foobar* fooey) {
    oneRelease(fooey->mutex);
}

and in the .C file:

foobar fooey;
construct_foobar( &fooey );
ObtainControl( &fooey );

edited May 03 '11 at 17:10

quamrana

37,849
12
53
71

answered May 03 '11 at 17:04

Dan F

17,654
5
72
110

3

You missed the final part: find every point at which `fooey` goes out of scope, and add calls to `destroy_foobar`. – Mike Seymour May 03 '11 at 17:14
yeah, that is true as well, you have to worry about automatic destruction on scoped variables – Dan F May 03 '11 at 17:15

score 0 · Answer 3 · edited May 23 '17 at 10:31

0

There are actually compilers that compile from C++ to C. The output is not meant for human digestion, though, see How to convert C++ Code to C.

edited May 23 '17 at 10:31

Community

1
1

answered May 03 '11 at 17:34

Tilman Vogel

9,337
4
33
32

thanks for the reference, problem is that the final code may very well need to be scrutinized (regulations...) – Rasman May 03 '11 at 17:52

score 0 · Answer 4 · edited May 23 '17 at 11:46

0

It depends on your compiler because there isn't a standard way of RAII in C. See this question and the top answer.

edited May 23 '17 at 11:46

Community

1
1

answered May 03 '11 at 17:59

Tamás Szelei

23,169
18
105
180

Converting a C++ class to a C struct (and beyond)

4 Answers4

Linked

Related