[RESOLVED] inherit __autoload() or define in each class?

[NogDog]

I was thinking that it might make sense to define an abstract class with an autoload() function, then have all other classes that are stand-alone or at the top of an inheritance tree extend that class. Then I would not need to remember to create the autoload() for each class that might need it. It makes sense to me as it greatly reduces duplicate code, I just wondered if anyone sees any downside to doing it this way.

Main.php:

/**
* top-level class from which all others inherit __autoload()
*/
class Main
{
   function __autoload($class)
   {
      require_once str_replace('_', PATH_SEPARATOR, $class);
   }
}

Example class:

class Example extends Main
{
   protected $test;
   public function __construct()
   {
      $test = new Test(); // will try to autoload Test class.
   }
}

[Weedpacket]

Um, I think you'd want __autoload() to be a global function, not a method.

If you don't want to have to remember to include the declaration containing it, you can auto-prepend it.

[NogDog]

Weedpacket wrote:

Um, I think you'd want __autoload() to be a global function, not a method.

If you don't want to have to remember to include the declaration containing it, you can auto-prepend it.

Yeah, I started playing around with it last night in a "real" situation, and ran into one obvious (after the fact) issue: you can't extend a class whose definition has not yet been loaded, so autoload() is no use if you want to simply require a child class and instantiate it without having to first include all of its antecedents. So now I'm thinking one global function as you suggested, and then have each class's autoload() call that function. At least I would still only have to edit one function for any changes.

[iceomnia]

I don't know if this is relevant but my shopping cart program kind of works like that...

class Program
{
	function __construct()
	{
		// Do some initialising
	}
}

class Cart extends Program
{
	function __construct()
	{
		// initialise the cart
	}

public function addToCart($itemId)
{
	// add to cart
}
}

class Products extends Program
{
	function __construct()
	{
		// constructor
	}

public function findProducts($searchStr, $catId)
{
	// search for products and return result as an array
}
}

This way I can inherit class resources, variables etc and it becomes quite useful rather than to declare static class variables.

[Weedpacket]

NogDog wrote:

and then have each class's autoload() call that function. At least I would still only have to edit one function for any changes.

I actually don't see the point of a method named "autoload()" - unless you call it explicitly for some reason, which invalidates the point of having it. PHP's autoload mechanism goes looking for a global function with that name.

test.php

function __autoload($name)
{
	require_once($name.'.php');
}

class Test1 extends Test2
{
	public function __construct()
	{
		echo "I'm in Test1!";
		parent::__construct();
	}
}


$t = new Test1;

Test2.php

class Test2 extends Test3
{
	public function __construct()
	{
		echo "I'm in Test2!";
		parent::__construct();
	}
}

Test3.php

class Test3
{
	public function __construct()
	{
		echo "I'm in Test3!";
		Test4::boing();
	}
}

Test4.php

class Test4
{
	public static function boing()
	{
		echo "Test4 goes boing!";
	}
}

[NogDog]

Doh!

The light finally goes on....When reading the examples in a book, for some reason I thought I was seeing the autoload() function being defined as a class method, and was therefore under the impression that each class had to have an autoload() for it to work.

After reviewing the replies here and then reading the manual pages and going back to my book, I realize the error of my ways.

So to quote Roseanne Roseannadanna, "Never mind."