Is there such a thing as a parent object?

Duke_Machesne

Not parent class, mind you. What I'm wondering if there's any way to set up a class whose objects will only ever be used by objects of another class (its 'parents'), and give the child objects the ability to call methods of the parent objects. Like this:

<?
class a {
    var $b;
    var $somevar = 'nothing';

function a() {
    $this->b = new b;
}

function a_function() {
    $somevar = 'something';
}
}

class b {
    function b_function() {
        // this, of course, is the tricky part
        $parent_object->a_function();
        // is there any way to do this?
    }
}

$foo = new a;
$bar = new b;

$bar->b_function();
print $foo->somevar;
?>

Ideally, {$foo->somevar} is now set to 'something'. But I haven't found any way to reference $parent_object->a_function().

The first thing I tried was to set up the constructor for class b to accept a reference to it's parent object. That didn't work, as PHP apparently starts making copies of the referenced object, which then each contain a new $b, and I ended up in a recursive. No good.

Does anyone know if this is even possible?

jeremuck

Yes.

parent::

Lets you access the parent's scope, but it doesn't allow you to access the variables.

Using get_parent_class might.

http://us3.php.net/manual/en/keyword.parent.php

I don't see why you couldn't set up some kind of message passing system to let objects know of each other's existence. Especially by using variable variable names.
ie:

class Cmyclass
{
  var $mystring;
  Cmyclass()
  {
    $mystring = "I'm here\n<br>";
  }
  function exist()
  {
    echo $mystring;
  }

}
class Cfooclass extends Cmyclass
{
  var $mystring;
  Cfooclass
  {
    $mystring = "I'm here too!\n<br>";
  }
  function exist()
  {
    echo $mystring;
  }
}

$objectarray = array("CmyClass" => "classone", "Cfooclass"=> "classtwo");

foreach($objectarray as $name=>$var)
{
  ${$var} = new ${$name};
}

Will that work?

Duke_Machesne

parent:: lets me access a parent class, it's true. But I'm not trying to extend a class, I'm trying to create a container object that contains one iteration of another object, and give the contained object access to its container.

I've found only one way to do this so far, and its not pretty.

<?

class foo {
    var $bar;
    var $somevar = 'nothing';

function foo() {
    $this->bar = new bar($this);
}

function setvar($var) {
    $this->somevar = $var;
}
}


class bar {	
	function bar(&$parent) {
		foreach(get_object_vars($parent) as $key=>$val) {
			if($key != 'bar') {
				$this->$key =& $parent->$key;
			}
		}
	}

function set_foo_var() {
    foo::setvar('something');
}
}



$foo = new foo;

print '<pre>'; var_dump($foo); print '</pre>';

$foo->bar->set_foo_var();

print '<hr>$foo->somevar = '.$foo->somevar;

?>

Tell me honestly: am I being dense for not just making bar extend foo and using a bar instead of a foo?

I think I may be.
:eek:

Duke_Machesne

The reason I didn't want to do that is because I've got my container object being passed around in my session, and I don't want to muck up my gigantic class with all the crap from the new guy.

There must be a way.

jeremuck

I think I read that that method causes a seg fault.
If you read the user contributed material, I think you'll find that many developers are facing the essentially the same struggle.

If you are simply seeking access to a datastructure, why not use arrays. Array handling in PHP is incredibly powerful...

I assume you are using the serialization power in PHP to move the class from session instances to session instance? Using __sleep()???

Also remember, if you are facing a bottleneck, is there a way you can just leave that step out? Can you serialize to database instead?

In my first reply, I realized after I wrote the parent:: stuff that wasn't what you wanted, but was too lazy to erase it. Did you check out the stuff I wrote below it?

Duke_Machesne

I did read the rest, and I'm still thinking about it. The only way I see to apply your idea is to put the container-object in globals, and then tell the inner object what its container's name is.

Let's see how we do with giving the inner object access to the global-scoped container...

class foo {
    var $bar;
    var $somevar = 'nothing';

function foo($my_name_is) {
    $this->bar = new bar($my_name_is);
}

function setvar($var) {
    $this->somevar = $var;
}
}


class bar {
	var $parent;

function bar($parent_name) {
	$this->parent = $parent_name;
}

function set_foo_var() {
	global $$this->parent;
	${$this->parent}->setvar('something');
}
}



$foo = new foo('foo');

print '<pre>'; var_dump($foo); print '</pre>';

$foo->bar->set_foo_var();

print '<hr>$foo->somevar = '.$foo->somevar;

That's not too shabby, as long as the container object is always global. A little kludgy, but more elegant than anything I can think of.

Thanks for the help
🙂

Whatd'ya think?

ahundiak

Maybe I don't understand the problem here but it's easy to get around the copy problem.

class CParent
{
  function some_method()
  {
  }
}
class CChild
{
  var $parent;

  function CChild(&$parent)
  {
    $this->parent =& $parent;
  }

  fucntion do_something()
  {
    $this->parent->some_method();
  }
}

$parent =& new CParent();
$child =& new CChild($parent);