Segfault with Embedded Structs and virtual functions

I have structs like this:

struct A
{
     int a;
     virtual void do_stuff(A*a)
     {
          cout << "I'm just a boring A-struct: " << a << endl;
     }
}

struct B
{
     A a_part;
     char * bstr;
     void do_stuff(B*bptr)
     {
          cout 开发者_JS百科<< "I'm actually a B-struct! See? ..." << bptr->bstr << endl;
     }
}

B * B_new(int n, char * str)
{
     B * b = (B*) malloc(sizeof(struct B));
     b->a_part.a = n;
     b->bstr = strdup(str);
     return b;
}

Now, when I do this:

char * blah = strdup("BLAAARGH");
A * b = (A*) B_new(5, blah);
free(blah);
b->do_stuff(b);

I get a segfault on the very last line when I call do_stuff and I have no idea why. This is my first time working with virtual functions in structs like this so I'm quite lost. Any help would be greatly appreciated!

Note: the function calls MUST be in the same format as the last line in terms of argument type, which is why I'm not using classes or inheritance.

You're mixing a C idiom (embedded structs) with C++ concepts (virtual functions). In C++, the need for embedded structs is obviated by classes and inheritance. virtual functions only affect classes in the same inheritance hierarchy. In your case, there is no relationship between A and B, so A's doStuff is always going to get called.

Your segfault is probably caused because b is a really a B, but assigned to an A*. When the compiler sees b->doStuff, it tries to go to a vtable to look up which version of doStuff to call. However, B doesn't have a vtable, so your program crashes.

In C++, a class without virtual functions that doesn't inherit from any other classes is laid out exactly like a C struct.

class NormalClass
{
      int a;
      double b;

 public:
      NormalClass(int x, double y);
};

looks like this:

+------------------------------------+
| a (4 bytes) | b (8 bytes)          |
+------------------------------------+

However, a class (or struct) with virtual functions also has a pointer to a vtable, which enables C++'s version of polymorphism. So a class like this:

 class ClassWithVTable
 {
      int a;
      double b;

   public:
       ClassWithVTable();
       virtual void doSomething();
 };

is laid out in memory like this:

  +-----------------------------------------------------------+
  | vptr (sizeof(void *)) | a (4 bytes) | b (8 bytes)         |
  +-----------------------------------------------------------+

and vptr points to an implementation-defined table called the vtable, which is essentially an array of function pointers.

Casting a B * to an A * and then attempting to dereference it via a member function call is undefined behaviour. One possibility is a seg-fault. I'm not saying that this is definitely the cause, but it's not a good start.

I don't understand why you're not using inheritance here!

For polymorphic objects, the pointer to the vtable is stored inside the object.
So at runtime, the method to be actually called is found via dereferencing and jumping into the vtable.
In your case you cast B * to A *.
Since A is polymorhic, the method call will be determined via the vtable, but since the object being used is actually B the vpointer used, is actually garbage and you get the segfault.