[PHP] Functie verwijzen naar een andere functie

[Werelds]

Beste tweakers,

Sinds kort ben ik weer eens bezig met een website, na lange tijd niets gedaan te hebben. Ondertussen heb ik wel veel met C, C++ en C# gewerkt, en nu wil ik in PHP een aantal dingen proberen. Ik ben met de C varianten veel verder gegaan dan ooit met PHP, en dat wil ik nu dus terug voeren.

Wat ik mij afvroeg, is of het mogelijk is een functie een reference te laten zijn naar een andere functie.

Het idee:

code:

class Class1 {
    tmpClass2 = new Class2();
    function C1F1() = tmpClass2->C2F1;
}

class Class2 {
    function C2F1($arg1, $arg2 = false) {
        /* ... */
    }
}

class Class3 {
    function C3F1($arg1, $arg2 = false, $arg3) {
        /* ... */
    }
}

Idee is dus dat de eerste class aangemaakt wordt, deze op zijn beurt Class2 danwel Class3 aanmaakt (afhankelijk van een aantal parameters), en dat dan vanuit het hoofdscript gewoon gebruikt gemaakt wordt van de dummy functies in Class1 die gelinkt zijn naar functies in Class2/Class3; met behoud van de parameters.

Klinkt misschien raar, maar ik heb hier zo m'n redenen voor

Iemand een idee? Heb al een aantal dingen geprobeerd, maar helaas

[Spockz]

wat je wel kunt doen is de tekstidentifier dus bijv Class1::Je_Functie in een string te zetten en die met call_user_func aan te roepen, voor statische functies. Of zo:

PHP:

<?php
class myclass {
    function say_hello()
    {
        echo "Hello!\n";
    }
}

$classname = "myclass";

call_user_func(array($classname, 'say_hello'));

Courtesy of php.net/function.call-user-func.php.

[crisp]

Of zoiets:

PHP:

class Base
{
    function Base($which)
    {
        switch ($which)
        {
            case 1:
                $this->sub = new Sub1();
                break;
            case 2:
                $this->sub = new Sub2();
                break;
        }
    }

    function waa()
    {
        $this->sub->waa();
    }
}

class Sub1
{
    function waa()
    {
        echo 'This is waa() from Sub1<br>';
    }
}

class Sub2
{
    function waa()
    {
        echo 'This is waa() from Sub2<br>';
    }
}

$foo = new Base(1);
$foo->waa();

$bar = new Base(2);
$bar->waa();

[prototype]

@TS:
Waarom zou je dat in dit geval zo willen? Van wat ik heb begrepen uit je code wil je in feite gewoon delegeren toch? Ik weet niet of PHP daar zelf mechanismen voor aanbiedt om method pointers toe te staan en al helemaal niet type safe method pointers, maar je hebt zover ik kan zien dit ook niet nodig voor jouw constructie.

Immers volstaat het volgende toch ook?

PHP:

class Class1 {
    private $blaat;
    public function __construct() {
        $this->blaat = new Class2();
    }

    public function delegateFoobar() {
        $this->blaat->foobar();
    }
}

class Class2 {
    public function foobar() {
        //...
    }
}

Natuurlijk wel netjes je argumenten meegeven.

edit:

Crisp

[FragFrog]

Kan ook algemener trouwens:

PHP:

class Foo {
  private $child;

  public function __construct ($class = false) {
    if (class_exists($class))
      $this -> child = new $class;
  }

  public function __call ($function, $arguments) {
    if(method_exists($this -> child, $function))
      $this -> child -> $function($arguments);
  }
}


class One {
  public function bar () {
    echo "One bar.";
  }
}

class Two {
  public function bar () {
    echo "Two bars.";
  }
}

$foo = new Foo('One');
$foo -> bar(); // Echo's 'One bar.';

$foo = new Foo('Two');
$foo -> bar(); // Echo's 'Two bars.';

Hiermee kun je willekeurig welke class gebruiken om te callen en willekeurig welke public functie in die class aanroepen zonder 'm eerst te hoeven definieren. Laat je nu nog vrij weinig zien als er iets mis gaat maar dat kun je prima zelf toevoegen met exceptions (of wat je voorkeur maar heeft).

* FragFrog is een groot liefhebber van magic methods

[ Voor 21% gewijzigd door FragFrog op 20-01-2008 13:24 ]

[Sh4wn]

PHP's eigen callback 'type' is

- Bij een functie: gewoon een string met de functie naam
- Bij een static method: een array met key0 de class name en key1 de functie naam
- Bij een niet static method: een array met key0 de instantie, en key1 een string met de functie naam

Zo zou je in principe verder kunnen lijkt mij

[prototype]

Ik heb je vraag even opnieuw gelezen en ik zie dat ik 'm een beetje verkeerd had opgevat. Wat je eigenlijk zoekt imho is de factory pattern. Het is een generalisatie van de oplossing van crisp, en ik raad je aan om er even naar te googlen.