oop class extends vererbung / referenz

[Ichier]

hi
ich benutze äußerst selten Klassen, bringt selten was, außer zeitverlust und die notwedigkeit das objekt hinterher aus dem speciher zu löschen...
bei komplexeren sachen soll es aber schon mal vorkommen
so z.B. jetzt:

ich möchte für eine aufgabestellung mit etlichen methoden und membern unter-objekte erstellen, die die member des eltern-objektes vererbt bekommen. allerdings nicht die des objektes in codeauslieferung sondern nach modifikation on runtime. hmm - so wirds deutlicher -->

class elter {
  public $var;

  function nkind() {
    $this->kind = new kind();
  }

  function show() {
    echo $this->var;
  }
}

class kind extends elter {
  function __construct() {
    $this->show();
  }
}


$obj = new elter();
$obj->var = 'value';
$obj->nkind();
$obj->kind->var .= ' was modified';
$obj->kind->show(); 

nun soll 'value' und anschließend 'value was modified' ausgegeben werden.

zwei möglichkeiten vermisse ich also, bzw. hab nich herausgefunden wies geht.

zunächst das (natürlich optionale) vererben der aktuellen werte des elternobjektes.
weiterhin, (prinzipiell - brauch ich grad aber nicht) natürlich selbiges als referenz statt als initialisierungsprozesses. sprich: kind ist bereits initialisiert, elter->var wird verändert, und somit die referenz elter->kind->var

sinn und zweck der geschichte ist eben das verfeinern gewisser aufgaben:

in elter werden defaults gesetzt, zunächst von der klasse, anschließend aber vom aufrufenden code!
sodann werden kindx und kindy (...) initialisiert und je nach aufgabe werden die werte vom aufrufenden code ein zweites mal angepaßt.


gibt es eine elegante, bestenfalls von php gegebene, lösung hierfür?

schön wäre sowas wie
class kind extends current elter {}
und
class kind extends reference elter {}

die möglichkeit elter zu übergeben oder dessen member via get_object_vars in einer schleife abzuarbeiten und so $this des kinds zu überschreiben halte ich für extrem bescheuert (kann ich mir fast schon extends sparen, wären da nicht noch die methoden), sehe aber grad keine bessere lösung.

tss, schon schlimm, da hat man endlich mal eine aufgabe in der sich oop wirklich als sinnvoll erweisen würde, und dann sowas!

vielleicht zum besseren verständnis noch angehängt dies:

class cousin extends elter {
  function __construct() {
    $this->show();
  }
}

$obj->cousin = new cousin();
$obj->cousin->show(); 

soll 'value' ausgeben

[onemorenerd]

Re: oop class extends vererbung / referenz

Kennst du __clone()?

Da mir nicht klar ist, wo im 2. Beispiel das 'value' herkommen soll, gehe ich darauf mal nicht ein.

[Ichier]

clone kenn ich aber das ist ja dann eine kopie des parent kein extending child mit zusätzlichen methoden :/ oder hab ich da was falsch in erinnerung?

der zweite codeschnipsel wird selbstverständlich an den ersten angehängt ... das cousin->show kann man sich sparen oder den constructor :P oder man hat 2 x 'value' als ausgabe - äh nee, sollte/wollte haben ... whatever. sollte nur zeigen, daß elter->var weiterleben muß, modifiziert.

[tontechniker]

Ich seh zwar noch nicht so denn Sinn aber mit Reflections kannst du sowas erreichen.

[Ichier]

Reflections : hmmm, wie denn?

ich kann mit dem begriff zurückentwickeln nicht viel anfangen. :/

habs mir allerdings nur kurz angesehn; das gefällt mir schonmal gar nicht :

Um einen Blick in eine Klasse zu werfen, muss man zuerst eine Instanz der Klasse ReflectionClass erzeugen. Man kann danach jede der oben angeführten Methoden der Instanz verwenden.

sah jetzt für mich aus, als ob ich damit auf die werte des parent zugreifen kann, was ich ja aber durch übergabe oder oder oder eh könnte, dann also ebenso im constructor in einer schleife nach self:: umschreiben müsste. oder hab ich was übersehen das es automatisch oder mittels performantem befehl erledigt.

ich sehe nicht ganz warum dir der sinn nicht ersichtlich ist
zunächst klassisch: basisklasse und diverse verfeinerte welche mit zusatzaufgaben -> extends
dann aber eben das gleiche mit den werten:
basiswerte aus der basisklasse
dann basiswerte aus dem aufrufenden code
und dann für spezielle fälle, eben den extended subclasses, nochmals abweichende werte
so wie im beispielcode halt

grundprinzip -> grundaufgabe -> spezialaufgabe

einfaches realbeispiel? *grübel*
hm, etwas sinnlos ...also würde so keiner machen mit sql outputmischmasch, und überhaupt... aber ergibt sinn ...najaaa, genaugenommen - in meinem, viel komplexerem, fall ist der sinn gegeben...

class  elter {
  var $db = 'localhost';
  var $table;
  var $select =  array('id');
  var $where;
  var $filename = 'export';
  var $encoding = 'UTF-8';

  function xml () {
    $this->xml = new elter_xml();
  }

  function csv () 
    $this->csv = new elter_csv();
  }

  function action() {
    return sqlselect($this->db,$this->table,$this->select,$this->where);
  }

  function send_file() {
    //blah
  }
}

class elter_xml extends elter {
  var $root = 'data';
  var $rows = 'dataset';
  var $extension = 'xml';

  function do_action() {
    $this->res = generate_xml($this->action(),$this->root,$this->rows,$this->encoding);
  }
}

class elter_csv extends elter {
  var $separator = ',';
  var $quotes = '"';
  var $extension = 'csv';

  function do_action() {
    $this->res = generate_csv($this->action(),$this->separator,$this->quotes,$this->encoding);
  }
}


$exp = new elter();
$exp->filename = 'kunden';
$exp->table = 'kundendaten';
$exp->select = array('kundennummer','name');

switch ($request) {
  case 'csv' : 
    $exp->csv();
    $exp->csv->separator = ';';
    $exp->csv->select[] = 'vorname';
    $exp->csv->where = array('flag_exclude_csv'=>0);
    $exp->csv->do_action();
    break;
  case 'xml15' : 
    $exp->xml();
    $exp->xml->filename .= '_iso8859-15';
    $exp->xml->encoding = 'ISO-8859-15';
    $exp->xml->root = 'kdb';
    $exp->xml->do_action();
    break;
}
$exp->send_file();
exit; 

hm, jetzt klarer? ist dasselbe nur ausführlicher


wenn solch eine funktionalität gegeben wäre von phpseite, so wäre das wesentlich performanter als innerhalb php-script blöd ne schleife abzuarbeiten

die lösungsmöglichkeit die ich sehe und für bescheuert halte:

class elter {
  function kind() {
    $this->kind = new nkind($this);
  }
}

class nkind extends elter {
  function __construct($par) {
    foreach ($par as $k=>$v) {
      if(!is_object($v)) { $this->$k = $v; }
    }
  }
} 

wenn dus dennoch nicht verstehst, wie würdet ihr denn sonst die aufgabe lösen?


zu clone fällt mir auch nix ein:

class elter {
  function kind() {
    $this->kind = clone $this;
    //wie krieg ich jetzt die extended methoden und member nach kind ?
  }
} 

[tontechniker]

Du hast einfach eine komplett falsche Herangehensweise: Statt erst das Elternelement zu erstellen, die Daten abzufragen und dann über das Kindelement die Daten zu verarbeiten solltest du erst überlegen was du willst, dann das Kind erstellen, mit diesem Objekt (über die geerbten Methoden) die Daten holen und dann verarbeiten:

class data {
    private $_data;
    
    public function fetchData ( ) {
        $this -> _data = sql ( ... );
    }    
}

class xmlData extends database {
    public function getAsXML ( ) {
        return getData ( $this -> _data );
    }
}

class cvsData extends database {
    public function getAsCVS ( ) {
        return getData ( $this -> _data );
    }
}

switch ( $request ) {
    case 'cvs':
        $data = new cvsData ( );
        break;
    case 'xml':
        $data = new xmlData ( );
        break;
}

$data -> fetchData ( );
print_r ( $data -> getData ( ) ); 

Ist alles etwas vereinfacht, die Methoden heißen der Einfachheit halber gleich. So macht man OOP - einen Anwendungszweck wo das so nicht geht kann ich mir im Moment nicht vorstellen -> ansonsten musst du dich mal etwas genauer äußern.

[Ichier]

Du hast einfach eine komplett falsche Herangehensweise

kann sein

Statt erst das Elternelement zu erstellen, die Daten abzufragen und dann über das Kindelement die Daten zu verarbeiten solltest du erst überlegen was du willst, dann das Kind erstellen, mit diesem Objekt (über die geerbten Methoden) die Daten holen und dann verarbeiten

näh, das nützt nich
(weil der aufrufende code aus verschiedenen quellen generiert wird, da iss nix mit fetch sql und auch nix mit einheitlicher class die das übernehmen könnte; es ist dynamischer code und von daher brauche ich auch diese funktionalität und diese hierachie, dieses vererbungsprinzip)

So macht man OOP

man vielleicht

ansonsten musst du dich mal etwas genauer äußern.

nagut, dann so:

ich brauche die funktionalität von

class elter {
  function kind() {
    $this->kind = new kind($this);
  }
}

class kind extends elter {
  function __construct($par) {
    foreach ($par as $k=>$v) {
      if(!is_object($v)) { $this->$k = $v; }
    }
  }
} 

damit ich folgendes machen kann:

$elter = new elter();
$elter->val = array(1,2);
$elter->kind(); 

mit dem ergebnis $elter->kind == array (1,2);

warum ist ja eigentlich egal. spar ich mir jetzt. vereinfachte beispiele sind oben.

aber so wies schient ist das nicht vorgesehn und man muß sich auf scriptebene damit herumschlagen, *grumpf*.
es wäre einfach umzusetzen, und auch eingefleischte oopler hätten ihren nutzen darin, dessen bin ich mir sicher, auch wenn es eine weile dauern könnte und umständliche techniken überdacht werden müssten.

statt erstgenanntem codeschnipsel wäre dies cool:

class elter {
  function kind() {
    $this->kind = new kind();
  }
}

class kind extends current elter {
  //
  // wobei fürs automatische vererben vorrausgesetzt würde, daß 
  // a) child innerhalb von parent instanziiert wird
  // oder
  // b) child als sub von elter insanziiert wird
  // oder maunell
  // c) parent übergeben werden muß wie in meinem workaround
  //
  // akzeptabel wäre auch noch eine funktion zum anwenden im constructor
  //
  // alles schneller als auf scriptebene
  //
} 

[PHP-Desaster]

Irgendwie checke ich absolut nicht, was du vor hast...

[combie]

Aber ich weiß, was er tut!!
Er beschäftigt min. 2 Foren mit seinem Problem!

@Ichier
Lesen:
http://www.peterkropff.de/site/tutorials/php_oop.htm
http://www.knusperleicht.at/index.ph...erung_mit_PHP5
http://www2.professionelle-softwaree...erste_auflage/

Zu den üblichen OOP Konzepten bzw. Design Pattern ist schon massig geschrieben worden. Google hilft dir weiter.

[Ichier]

danke combie, allerdings habe ich bisher durchaus zugang zu den handelsüblichen informationen gehabt. abgesehen davon, daß ich php-oop nicht nicht nutze, da mir grundliegendes verständnis fehlt, sondern mir die performance nicht paßt, sind es gute links.

performance ist auch das was ich mit diesem post will. (ist vielleicht zu zeiten da gpu schneller sind als cpu, schwer zu verstehen.)

daher auch der identische post auf selfphp ...um zu einem ergebnis zu kommen braucht es bei unkonventionellen fragen viele nerds um den heißen brei herum.

was ich an funktionalität brauche habe ich oben mittels meines workarounds exakt beschrieben. ich brauche exakt dieses verhalten.

falls nicht klar ist was dieser code bewirkt. so läßt sich das zuhause ausprobieren oder nach lektüre der oben genannten links sicher nachvollziehen.

was ich suche ist eine php-native methode diese art von vererbung zu bewirken.
da ich mir zunächst nicht vorstellen konnte, daß eine deratig praktische funktionalität nicht vorghanden ist, und mich nur für zu müde hielt beim überfliegen der literatur den knackpunkt zu finden, meine posts.

und: ja, mir ist bewußt daß ich das prinzip oop ein wenig auf den kopf stelle. nur komischerweise hätte es mittels der von mir erwarteten implementierung eine funktinalität, die besser nicht umzusetzen ist. oder gibt es noch andere möglichkeiten?

auf der anderen seite mache ich nichts als 0815-oop. bloß daß ich keine default-werte einer basisklasse vererben möchte sondern die aktuellen eines objektes.

vielleicht ist das der punkt der nicht klar ist? es geht um WERTE. dynamisch festgelegt, on the run, jedes mal anders. sie sollen vererbt werden.

doch. es ergibt sinn. es ist ziemlich praktisch, sogar.


mein heut mittag erdachtes workaround hat übrigens mindestens noch einen fehler, wie ich grad sehe :

class elter {
  function kind() {
    $this->kind = new kind($this);
  }
}

class kind extends elter {
  function __construct($par) {
    foreach ($par as $k=>$v) {
      if( !is_object($v) && !isset($this->k) ) { $this->$k = $v; }
    }
  }
} 

so und finally zur performance und meiner intention:

meine überlegung ist diese:
beim erstellen des kind-objektes wird die elternklasse einmal durchlaufen.
beim workaround nehme ich mir nun das elternobjekt zur hand und lasse es nochmals durchlaufen um die werte ins kindobjekt zu vererben.
das ist unnötig!
könnte ich nativ ein objekt vererben, so würde dieses einmal durchlaufen werden und wir sparen uns 50% initialisierungszeit. mehr noch, da ich davon ausgehe, daß der durchlauf auf scriptebene verhältnismäßig länger dauert!

nu? alles verstanden? jemand eine bessere lösung?

danke, nïkö


btw wer ist eigentlich für das forum zuständig? ist ja anstrengend, nach timeout ist der bezug zum thread weg, beim einloggen braucht man 2xtab ...

[combie]

nu? alles verstanden?

Nöö...
Eltern dürfen nix über ihre Kinder wissen!
Du verstößt dagegen......
Und dabei kann ich dir nicht helfen.

Dein Beispiel verstehe ich auch nicht!!
Klar, was es tut ja, aber nicht, was du wirklich erreichen möchtest und warum das unbedingt so gemacht werden soll... da gibts bestimmt ganz andere Mittel und Wege!

dynamisch festgelegt, on the run, jedes mal anders. sie sollen vererbt werden.

Man kann keine dynamischen Werte vererben!
Wie auch?

[tontechniker]

Fragt sich natürlich warum die Daten dann nicht per Konstruktor übergibts. Das was du machst ist jedenfalls keine Lösung.

[PHP-Desaster]

Eine Übergabe von Werten in der Vererbung ist natürlich quatsch. Vielleicht ist das Prototypmuster etwas, das du suchst!

[Ichier]

combie, mit dogmatismus kommen wir hier nicht weiter. löblich, daß du die grundlagen beherrschst. aus einem stahlhelm kann man auch suppe essen. war dafür allerdings nicht vorgesehen. ist aber komischerweise effizienter als die hände zu nehmen solange die schüssel und der teller noch nicht erfunden sind. wir wollen hier eine problemlösung finden. code muß sauber, effizient, schlüssig uvm. sein, aber um gottes willen: niemals religiös!

btw: es ist technisch egal, praktisch praktischer, wenn ich eine spezifische wrapperklasse baue, die kindobjekte instantiiert, die genau weiß was sie tut, die kindobjekte beherbergt, als es manuell zu machen:
$a->b = new c();
ist das selbe wie
mein o.g.
$a->b();
wenn b() dann self::b = new c(); ist
das wird noch interessanter wenn ich subs gleich im constructor instantiiere... das nur am rande, fuck religion, start to think!

Man kann keine dynamischen Werte vererben! Wie auch?

indem man vom objekt erben könnte.
wie das gehen könnte habe ich zuvor skizziert.
einen weg, wie das praktisch umsetzbar ist, habe ich mit meinem o.g. workaround gezeigt.

da gibts bestimmt ganz andere Mittel und Wege!

natürlich! ich hoffe doch. es gibt immer mehr als eine lösung. oft sogar mehrere gute. deshalb bin ich hier im forum.
zeig mir doch bitte einen Weg!
ich hab nämlich noch keinen gefunden. deshlab bin ich hier im forum. was bewirkt werden soll ist ja bereits geklärt und anhand des o.g. codes exakt definiert. (... da fehlt noch ein $ bei !isset($this->$k) )

ich hab auch noch ein ganz simples praxisbeispiel ausgedacht: settings:
system gibt werte vor (basisklasse). - user passt werte an (basisobjekt). - für eine besondere aufgabe gibt es zusätzliche werte und das system überschreibt außerdem ein paar der basiswerte (kindklasse). - der user wiederum paßt sich hierfür diverse werte an, ebenfalls die basiswerte überschreibend (kindobjekt).

@ tontechniker : was meinst du mit per konstruktor? das macht das workaround doch; aber ich möchte ja das zweifache durchschleifen der klasse, insbesondere des objektes auf scriptebene, beim instantiieren vermeiden.

@ phpdesaster : klingt vielversprechend, auch wenn es nur ein designpattern ist, werd es mir jetzt mal genauer in bezug auf php ansehn und wie ich meine methoden und member erweitern kann.

[combie]

Du verwechselst Dogmatismus mit Disziplin!!

Du willst dort eine Rückbezüglichkeit einbauen, welche fast nur mit PHP überhaupt möglich ist! Meist muß man Klassen VOR der Verwendung deklarieren. PHP öffnet an ettlichen Ecken und Kanten massig Möglichkeiten für Schweinereien.

Deinen (meines bescheidenen Erachtens nach falschen) Weg hast du ja jetzt oft genug beschrieben. Aber was du wirklich erreichen möchtest, ist mir bisher noch lange nicht klar!

Ach ja: Nicht jede Kuh sollte auf dem Performace-Altar geopfert werden..

von wahsaga:
ForenpostingMitPerformancefrageBewertungsfaustregel:
Wer Fragen nach der Performance solcher Kinkerlitzchen stellt, der programmiert
vermutlich noch nicht mal ansatzweise performant.Andernfalls, wenn er wirklich
und zu Recht an einer Applikation arbeiten würde, bei der dieses Quentchen
entscheidend ist, sollte er diese Frage gar nicht mehr stellen müssen.

-----------------
PS:
Ich habe mir deinen Post vom 29-10-2007 17:21 noch mal durchgelesen. Wenn ich das richtig verstanden habe, soll dein "elter" verschiedene Klassen erzeugen können, welche verschiedenste Ausgaben tätigen sollen bzw. DB Inhalt in csv,pdf,jpg,xml,html verwandeln.

Mein Vorgehen wäre in diesem fall ganz klar!!
Als erstes wird ein gemeinsames Interface erzeugt.
Würde bei dir ja gar nicht viel brauchen..
Eine Funktion action() und eine send_file(), oder?
So, und die jeweils benötigte Klasse würde ich mir von einer Implementierung des Factory Design Pattern bereitstellen lassen. Dieses dürfte die sauberste und performanteste Methode sein!!

Als Beispiel, könnte ich dir hier auf Wunsch eine rudimentäre DB Klasse zeigen welche von einer Fabrik erzeugt wird.