Mixing C-Style Structures with C++

Question

I'm no C++ expect, as you will undoubtedly notice. But I'm trying to "upgrade" some old C code to C++. In the process, I'm trying to promote old structures to classes. I found this Oracle article about some of the things I'm trying to do.

http://www.oracle.com/technetwork/articles/servers-storage-dev/mixingcandcpluspluscode-305840.html

But 2 things. The article doesn't address a more complicated case I have. And my "workaround" doesn't seem to lead consistent results. So here I go with some details.

Old C-Style structure:

typedef struct
{
    int ia;
    float fa;
    ...
} Struct_A;

typedef struct
{
    Struct_A sA;
    int ib;
    float fb;
    ...
} Struct_B;

C++
According to the Oracle article, I should be able to promote Struct_A to a class and still be able to use the class version with old C functions. Here's apparently how:

class CStruct_A : public Struct_A  // Inherits from C- Struct_A
{
public:
    CStruct_A() : ia(0), fa(0.0f) {}
}

Pause. Right here, I already have an issue. I can't seem to initialize the C-Structure elements as indicated in the article and as shown above. The compiler doesn't accept it. I have to re-write the class as:

class CStruct_A : public Struct_A
{
public:
    CStruct_A()
    {
        ia = 0;
        fa = 0.0f;
    }
}

So that's the first question mark. Not a huge deal but the article claims it can be done.

Next, the tougher issue. Promoting the Struct_B, which contains a Struct_A member. I want to make sure Class A's constructor is used to initialize the variables. But I'm not sure how to force it. In my c++ code, if I have something like:

{
    CStruct_B *pCStrb = new CStruct_B();
    ...
}

Class B's constructor gets invoked but not class A's. The workaround I have is lame... But that's the only thing I can figure out for now. I declare an internal private function ini() in class A, make class B a friend and call init() from class B's constructor.

class CStruct_A : public Struct_A
{
    friend class CStruct_B;

public:
    CStruct_A() { init(); }

private:
    void init()
    {
        ia = 0;
        fa = 0.0f;
    }
}

class CStruct_B : public Struct_B
{

public:
    CStruct_B()
    {
        ib = 0;
        fb = 0.0f;
        static_cast<CStruct_A *>(&sA)->init();
    }
}

I have more questions but this is probably already too long.

Any help will be greatly appreciated.

Answer 1

I've skimmed through the "Oracle article" you referenced, and I find nothing in that article that suggests that you can initialize base classes in the manner you claim the article describes, or gives an example with anything anywhere close to the syntax you are trying to compile.

C++ classes' constructors can only initialize members of their class. They cannot initialize any members of their superclass directly from their constructor.

Having said that, some compilers might offer their own compiler-specific language extensions. For example, gcc 5.1 will accept the following code in -std=c++11 mode:

typedef struct
{
    int ia;
    float fa;
} Struct_A;

class CStruct_A : public Struct_A {

public:

CStruct_A() : Struct_A({
            .ia=1,
            .fa=0,
    })
    {
    }
};

But, that's horribly inefficient and is not standard C++ (as gcc will warn you in -Wpedantic mode).

Answer 2

Alright...

To close this question, I guess the only way I found to initialize the sub-structure is pretty much to do what I did in my workaround. I haven't found another, direct way. I guess it isn't a big deal. I was just mislead by the original article.

Now, the old code has a global Struct_B defined as "extern" and my new c++ program must allocate it. To be able to use its promoted features while still be "defined" from the old C-code perspective, I declared it as:

{
    Struct_B *pCStrb = new CStruct_B();
    ...
}

So I declare it as the old c-structure but allocate it with the class version. This is different than what I had originally written above, where I used the "C++" version to declare it. That was obviously wrong as the old C-code doesn't know anything about a structure called CStruct_B.

Anyway... seems to be doing what I wanted, albeit not exactly "as" I wanted.

Thanks for the help.

Answer 3

To address your first issue. From a C++ perspective, these C structs are considered aggregates. So you can do:

class CStruct_A : public Struct_A
{
public:
  CStruct_A() : Struct_A{0, 0.0f} {};
}

This works perfectly for me. The braces initializer is just initializing Struct_A in the order of its members.

The best that I can see to deal with your second issue is to give CStruct_A an implicit conversion back to Struct_A, and use that.

struct A {
  double x;
  int y;
};

class Ac : public A {
public:
  Ac() : A{0.0, 1} {};

  operator A() const { return A{x, y}; }
};

struct B {
  B() : a(Ac()) {};

  A a;
};

Edit: all that said, I'm not really sure that inheritance is the first place I'd look to solve this problem. I'd almost certainly rather start by encapsulating the C style structs in C++ classes and go from there.

To elaborate how I would do this:

class CStruct_A {
// ... various other code, initializes a carefully etc
public:
  Struct_A * getA() { return &a; }
private:
  Struct_A a;
}

Now, given some function:

void func(Struct_A * var);

Call it like this:

CStruct_A my_var();
func(my_var.getA());

It may not be as fancy as using inheritance, but it's simple, it works, it allows you to fully encapsulate the C structs and decide how they are initialized, the compiler will protect you against accidentally calling func(myvar), etc. I'd prefer this over inheritance unless there's a more compelling reason to use inheritance than you outlined.