Convert huge classes into instances with appropriate constructors and initialized cross-references; replace static member accesses with indirect accesses as appropriate; and get that working. Now, approach the project as an ill-factored OO application, and write unit tests where dependencies are tractable, and decompose into separate classes where they are not; the goal here would be to move from ... More on stackoverflow.com

You code in C++, then when we need ... the C++, convert it into C, and deploy. Then you continue to edit the C++ code and we repeat. So there's no longer any advantage in C is there? 2015-03-19T15:25:24.96Z+00:00 ... It handles some code, but will fail for more complex implementations as it hasn't been fully updated for some of the modern C++ conventions. So try compiling your code frequently until you get a feel for what's allowed. Usage sytax from the command ... More on stackoverflow.com

param_t could use some operator overloading,arr_t can be replaced by std::span and ARRAY by std::array. The whole thing could probably be made constexpr as well. Beside that, the code is very straight forward so there isn't many opportunities to use C++ specific features. More on reddit.com

Pretty much, yes.

The classes become structs with a (separate) set of functions; usually you prefix the names so it’s clear what they act on. You’ll need to to manual de-/initialization too. E.g.,

class C {
private:
    int x;
public:
    C() : x(0) {}
    C(const C &c) : x(c.x) {}
    C(int xv) : x(xv) {}
    int getX() const {return x;}
};

becomes something like

typedef struct C C;
struct C {
    int x;
    /* If you need to, you can also partition this like
    struct {
        int x;
    } private__;
    but it’s not like the C compiler will actually enforce privateness. */
};
void C_init_1(C *const inst) {inst->x = 0;}
void C_copy(C *const inst, const C *const c) {inst->x = c->x;}
void C_init_2(C *const inst, int cv) {inst->x = cv;}
int C_getX(const C *const inst) {return inst->x;}

If C extends something, it has to start with a copy of that thing; e.g.,

class D : public E, public F {…};

becomes

typedef struct D D;
struct D {
    E super_E;
    F super_F;
};

so static upcasting from D to E becomes &inst->super_E and the reverse is something like (struct D *)((char *)inst - offsetof(D, super_E)).

Virtual stuff gets into a whole other layer of crazy. A class with virtual members (including inherited ones) becomes something like

typedef struct V V;
struct V__vtable;
struct C {
    const struct V__vtable *vtable__;
    …
};
struct V__vtable {
    (virtual function pointers here)
};

and then you have to figure out a way to do dynamic casting (exercise for the reader:).

Templates usually end up as macros, and there’s really no good way to handle that uniformly; you’ll have to manually come up with names for the template instantiations and make sure things get pasted together properly. They might not be as bad if you use a separate header for each template and take macro args (#undef at end of file), then #include the header whenever you need to instantiate the template.

So you can do it, but it’s almost not worth it if you have any way to just shim into the C++ code from C. (E.g., come up with some extern "C" functions that let you access the C++ side of things.)

More on reddit.com