3 class-related questions

aliendesaster

Hi,

I have got three questions:

first:
how to access a uninstanciated (abstract) class (I´m using php 5 rc1) if the classname is beeing hold in a string variable?

class foo
{
public static $INT_Count=999;
}
$x="foo";
echo "INT_Count is ".$x::$INT_Count;//trying to access $INT_Count in foo doesn´t work

Is this already implemented? Are there any reasons not to implement it?

My seconds question is if you guys know an article about classes in php where the pros and cons
of instanciating(foo=new bar()) or not instanciating a class(foo::bar()) are beeing discussed?

Third:
This is my current class hierarchitecture:

abstract class core //loads all other classes in it´s own scope
{
public function Init($STR_File) {...} //Includes php file which loads the classes below
abstract class filesystem //which may extend other related classes
abstract class database //which may extend other related classes
abstract class login //which may extend other related classes
abstract class session //which may extend other related classes
[...]
}

core::Init("batch/normal.inc.php");

Currently all classes are abstract and accessed via the :: operator.
Is this bad coding? Are there any reasons to make an instance of the core class?
Instanciating needs more memory and consumes more cpu, is this correct?
So if I don´t need multiple instances of an object, I really don´t need one instance at all, right?
How would you do it-what´s the common way of doing it "right"?

Thank you

swr

The usual way is to use an instance. If you're doing everything with classes instead of objects, you probably don't really understand OOP.

Using classes instead of instances may save memory, but not much. If you have N classes, then from the sound of things you would only have N instances. If you can actually write the classes, then N is a relatively small number, so the amount of memory saved is fairly small.

The whole point of using instances is that you can have more than one, and each instance has its own variables.

As for class heirarchy... Usually extending a class implies a very specific type of relationship. This is usually described as an "is a" relationship. For example, if you have a "form_element" class, you'd probably have "class checkbox extends form_element" and "class textfield extends form_element" etc, because checkboxes and textfields are form elements. In that case form_element would probably be an abstract class, never instantiated, existing only to be subclassed, because you never just have a "form element" it is always a checkbox or textfield or whatever. The form_element class would contain code common to all kinds of form elements, like "set name" or whatever, to be inhereted by the subclasses.

ahundiak

I couldn't find the answer to your first question. You might try the general mailing list. Please report back if you do find the majic syntax.

Static class variables are usually intended to store information common to instances of a given class. The zend page http://www.zend.com/php5/articles/engine2-php5-changes.php
has an example of storing a class counter.

Could you use a static variable to store the connection information in a database class? Maybe but that's certainly not normal. Usually you would go ahead and create one instance of these types of classes. It's called a singleton. I'd suggest avoiding the static route even if it appears to work.

aliendesaster

@: Thank you
@: Well currently php is not capable of doing that it seems, but there rather an ugly hack to bypass php syntax. The function is called call_user_func.

class foo
{
public static $INT_Count=999;
function GetCount()
{
return foo::$INT_Count;
}
}
$x="foo";
echo "INT_Count is ".call_user_func(array($x, "GetCount"));

Thank you for your comments I´ll try to use instances. Actually I used instances only a while back, but then I tried the static way which worked too without having to handle with instances. That´s why I asked here😉

Weedpacket

I agree with ahundiak's recommendation of using a singleton - one never knows when one might need two instances, after all 🙂 - but it amused me to write this:

<?php
class foo
{
	static $bar = 999;
}

$thingy = 'foo';

echo eval("return $thingy::\$bar;");

?>

As someone else on these forums noted (I forget who, so I'm afraid I can't accredit them properly), if eval() is the answer, then the question was probably wrong 🙂

As for your third question: all you're doing here is using classes as function libraries, and you might as well just declare plain functions and avoid the OO overhead.