Multiple Inheritance

[beakie]

I have a struct with multiple inheritance.

struct RS_A {
	int count;
};

struct RS_B {
	int * values;
};

struct RS_AB : public RS_A, RS_B {
};

This snippet of code errors:

RS_A * s;
s = new RS_AB;

//.....//

((RS_B *) s)->values[i] = 1; //error

What's wrong, please?

(I know I could restructure my code but I would like to know the answer to this specific issue)

[kbw]

Why are you casting? I find myself repeating this, do not cast. You're overriding the type system, which usually means you're doing something wrong.

RS_B is not publicly inherited in your example.

struct RS_A
{
        int count;
};

struct RS_B
{
        int* value;
};

struct RS_AB : public RS_A, public RS_B
{
};

int main()
{
        RS_AB* pAB = new RS_AB;
        pAB->value = 0;

        return 0;
}

[beakie]

If I change the line to this, it works fine.

((RS_AB *) s)->values[i] = 1;

The problem is that I have lots of versions of RS_AB.

The only shared inheritance between all the versions of RS_AB is the use of RS_A.

[kbw]

Why are you casting?

[beakie]

struct RS_A {
	int count;
};

struct RS_B {
	int * values;
};

struct RS_C {
	int * values;
};

struct RS_D {
	int * values;
};

struct RS_E {
};

struct RS_sAB : public RS_A, RS_B {
};

struct RS_sAC : public RS_A, RS_C {
};

struct RS_sADE : public RS_A, RS_D, RS_E {
};

struct myStruct {
	RS_A * s;

	void somefunc() {
		((RS_C) s).values[0] = 0;
	};
};

void main() {
	mystruct temp;
	temp.s = new RS_sAC;
	temp.somefunc; //i would only call this when s is a class that inherits from C, like now.

	mystruct temp2;
	temp.s = new RS_sAB;
	//not called
}

[beakie]

(look at new example)

I am casting because s is RS_A which isnt a type of RS_C.

[kbw]

You have to be extremely careful when using multiple inheritance.

It's generally accepted that you should not multiply inherit implementation. However, flavours/mixins are a legitimate pattern, and there are other patterns that use it.

Having said all that, I still can't see why you need to cast. I'm not so sure about the design. I would probably like to see the UML class diagram, but that's clearly not necessary here.

[Peter87]

kbw wrote:

RS_B is not publicly inherited in your example.

It is publicly inherited because he use struct.

[beakie]

I need the cast because if I didn't have it I would get an error because RS_A doesn't have a method called somefunc()

[Peter87]

I also don't understand this. None of the RS types has a member function named somefunc().

[beakie]

mystruct does?

[kbw]

I still don't see why you think you need a cast.

struct myStruct {
	RS_A * s;

	void somefunc() {
		// RS_A doesn't have member value, and casting won't produce one
	}
};

[Peter87]

RS_A doesn't have a member called values so that does not work. If you want s to point to something that is not a RS_A object why do you make s type RS_A*?

[beakie]

I still don't see why you think you need a cast.

RS_A doesnt have variable values

edit: (This related to the code before your edit)

[beakie]

RS_A doesn't have a member called values so that does not work. If you want s to point to something that is not a RS_A object why do you make s type RS_A*?

I could have declared it as a void pointer, but the problem would still exist, no?

I made it RS_A because they are all of type RS_A... its the one struct they all share.


Why doesn't casting a pointer, as a struct the class inherits from, find elements within it when multiple inheritance is used?

[kbw]

That's right.

Your code fails to compile without the cast because the compiler is telling you that you have done something wrong. And you are. RS_A doesn't have a member value and pretending it does with a cast won't make it true.

You're attempting to override the compiler's static type checking, and if you succeed, you'll have a run time crash.

[beakie]

I (kinda) get ya, but I need to understand this a bit better so I will continue.

struct RS_A {
	int count;
};

struct RS_B {
	int * values;
};

struct RS_C {
	int * values;
};

struct RS_D {
	int * values;
};

struct RS_E {
};

struct RS_sAB : public RS_A, RS_B {
};

struct RS_sAC : public RS_A, RS_C {
};

struct RS_sADE : public RS_A, RS_D, RS_E {
};

struct myStruct {
	void * s;

	void somefunc() {
		((RS_C) s).values[0] = 0;
	};
};

void main() {
	mystruct temp;
	temp.s = new RS_sAC;
	temp.somefunc; //i would only call this when s is a class that inherits from C, like now.

	mystruct temp2;
	temp.s = new RS_sAB;
	//not called
}

What about this? It's now a void pointer.

[Peter87]

i would only call this when s is a class that inherits from C, like now.

Then why not make s type RS_C* and get rid of the cast?

[beakie]

Then why not make s type RS_C* and get rid of the cast?

This code comes from a much bigger piece of code.

There are other functions in mystruct that are only called when s contains an instance of RS_B or RS_D or RS_E or RS_F or...

[beakie]

I can't get my head around why casting a pointer would make such a difference. Surely its just a pointer (with type info). Why does casting it not just make it the appropriate pointer type???