"Parallel" Inheritance

[wdseelig]

Multiple inheritance is not available within PHP. But there are problems with what might
be called parallel inheritance as well.

Suppose, for example, that you want to derive a number of classes from one common base class.

class A
{
var $varA;
function funcA()
{
... some stuff
}
}
Class B extends A
{
var $varB;
function funcB()
{
... more stuff
}
}
class C extends A
{
var $varC;
function funcC()
{
... still more stuff
}
}
$Bobj = new B;
$Cobj = new C;

All you are trying to do here is make the variable $varA and the function funcA
available to both B and C.

What you will discover, though, is that B and C each have their OWN copy of class A,
its variables, and its functions. Thus setting varA in B will NOT affect the value
of varA found in C, and visa versa!

The only solution I've found to this dilemma is to have B extend A, and then C
extend B, and then just instantiate C. This doesn't make much sense if B and C
really don't have anything to do with each other, but at least it keeps things down
to one copy.

Does anybody have a fix for this???

[van__]

Wyckham Seelig wrote:

Does anybody have a fix for this???

Why fix what isn't broken.
The thing with PHP implementation of OOP is that you need to understand Scope and how to work amongst many scopes and their instances.

Classes only inherit methods and values that are the defined class values by use of the 'var' declaration.

So forget about working with class As' scope.
Instead, work with the $GLOBALS.
This is a handy dandy array that lives in all scopes simultaneously.

So try...
in class A:
$this->some_var = 4;
$GLOBALS['some_var'] = $a->some_var;

in class B:
$this->some_var = 3;
$GLOBALS['some_var'] += $b->some_var;

in class C:
$this->some_var = $GLOBALS['some_var'];

And you want to get funky?
Then do what I do:
$GLOBALS['myClass'] = new classObject();

and it's now a flying object!

[Anon]

$varA is an instance variable, so $Bobj and $Cobj have their own copies of $varA. So PHP's behaviour is correct.

I'm not sure if it'll work in PHP, but in other languages you can make $varA a static variable so that all instances will share the same $varA.

Diego

[wdseelig]

Just figured out another way to get around the multiple-copies problem.

Keep classes B and C independent of A (i.e., no extends) but pass the object A to these
classes so that they will know what is going on in A. Here is how this would work:

class A
{
var $varA;
function A ()
{
$Bobj = new B($this); // Call the B constructor with the object A
$Cobj = new C($this); // Call the C constructor with the object B
}
function funcA()
{
.... some stuff
}
}
class B
{
var $varB;
var $Aobj;
function B($obj)
{
$this->Aobj = &$obj; //B can now access A via $this->Aobj->(... properties, methods, etc.)
}
function funcB()
{
... some more stuff
}
}
class C
{
var $varC;
var $Aobj;
function C($obj)
{
$this->Aobj = &$obj; //C can now access A similarly
}
}

This now makes it possible for both B and C, which could be completely unrelated objects,
to access a "base" class A. Class A, for example, might have common error handling routines
for the entire site, and now subordinate classes can access that code without worrying about
whether there are multiple copies of variables running around.

The solution that van proposes (basically using global variables) will work, but if you want
to centralize some functionality, then you need to do something like this or keep stacking up
inheritances (C extends B , B extends A) etc.

I haven't tried Diego's solution (static variables), but that wouldn't resolve the need to use the
same functions from multiple classes, anyway.

[wdseelig]

The comment on the statement that instantiates a new C object is wrong. You are, of course, calling the C constructor with the object A (not 😎