Conception de classe

Version imprimable

Bonjour,

J'ai un problème avec la conception de deux de mes classes. Voici actuellement où en est mon code:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
<?php
  class FirstClass
  {
    private $mySecondsObjects, $myData;
    public __construct()
    {
      $mySecondsObjects=Array();
      $mySecondsObjects[]=new SecondClass()
    }
    public function SetMyData($data)
    {
      $this->myData=$data;
    }
  }
  class SecondClass
  {
    public function __construct()
    {
    }
    public function setMyDataAtTen()
    {
      /* Je recherche la variable à mettre ici */->setMyData(10);
    }
  }
?>

Mon besoin est donc, à partir de mon objet "SecondClass", d'appeller l'une des méthodes de l'objet de type "FirstClass", auquel il appartient.
J'avais pensé à un code de ce genre, mais je ne suis pas sûr que ça marche (je n'ai pas moyen de tester le script avant qu'il ne soit fini):

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
<?php
  class FirstClass
  {
    private $mySecondsObjects, $myData;
    public __construct()
    {
      $mySecondsObjects=Array();
      $mySecondsObjects[]=new SecondClass(this)
    }
    public function SetMyData($data)
    {
      $this->myData=$data;
    }
  }
  class SecondClass
  {
    private $firstObjectPointer;
    public function __construct(&$parameter)
    {
      $this->firstObjectPointer=&$parameter
    }
    public function setMyDataAtTen()
    {
     $firstObjectPointer->setMyData(10);
    }
  }
?>

Qu'en pensez vous?

Merci d'avance,
ProgVal

Bonjour,

Mis a part les petites fautes de syntaxe.

Je pense que si tu on te demande une troisième classe (ThirdClass ) puis une quatrième etc ... tu serra vite très ennuyé avec cette structure de code.

Je pense aussi que si tu utilise __construct c'est que tu utilise PHP 5 et de ce fait, tu ne devrai pas utiliser le déférencement (&)pour un object(class)
Ainsi, au lieu d'écrire :
Code:

1 2 3 4 public function __construct(&$parameter) { $this->firstObjectPointer=&$parameter; }
Il faudrai écrire :
Code:

1 2 3 4 public function __construct( $parameter) { $this->firstObjectPointer = $parameter; }
Voici un petit bout de code qui pourrai qui pourrai te donner un réflechir
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 Class Element { private $parent; private $children; public $data; function __construct() { $this->parent = null; $this->children = array(); $this->data = array(); } function addChild( $object ) { $object->parent = $this; $this->children[] = $object; return $object; } } $a = new Element(); $c = $a->addChild( new Element() ); print_r($a);
Crdlt,

16/09/2009, 17h40
ProgVal

Merci pour ta réponse.

Le problème est que je ne veux pas copier l'objet parent (car il contient des données susceptibles de changer n'importe quand).

Et je n'ai que 3 classes, au total (Serveur, Canal, Utilisateur).

passage par référence et par copie en PHP

En réponse à :

Citation:

Le problème est que je ne veux pas copier l'objet parent

Justement ! En PHP5 le passage des Object(class) ce fait par référence et non plus par copie comme en PHP4. Ainsi, en PHP5, dans le code ci-dessous, la variable $foo contient la référence(aussi appelé pointeur ou alias) vers l'espace mémoire alloué pour cette object -l'instance- :

Code:

$foo = new MaClass();

Exemple :
Soit la class Foo :
Code:

1 2 3 4 5 class Foo { public $property; function Foo() { $this->property = 'undefined'; } }
Voici une utilisation de class en php 4 (passage par copie par défaut)
Code:

1 2 3 4 5 6 $foo = new Foo(); $foo_tmp = $foo;// passage par copie : on duplique l'object en mémoire $foo_tmp->property = 'value'; echo $foo->property;// output : undefined echo $foo_tmp->property;// output : value
Voici une utilisation de class en php 5 (passage par référence par défaut)
Code:

1 2 3 4 5 6 $foo = new Foo(); $foo_tmp = $foo;// passage par référence : on pointe la même adresse mémoire $foo_tmp->property = 'value'; echo $foo->property;// output : value echo $foo_tmp->property;// output : value
Passage par référence en PHP 4 :
Code:

1 2 3 4 5 6 $foo = new Foo(); $foo_tmp = & $foo;// passage par référence : on créer un alias de la variable $foo $foo_tmp->property = 'value'; echo $foo->property;// output : value echo $foo_tmp->property;// output : value
Passage par copie en PHP 5 :
Code:

1 2 3 4 5 6 $foo = new Foo(); $foo_tmp = clone $foo;// passage par copie : new instancie, et clone duplique $foo_tmp->property = 'value'; echo $foo->property;// output : undefined echo $foo_tmp->property;// output : value
En ce qui concerne les autre classes(Serveur, Canal, Utilisateur), j'en pense que du bien^^

19/09/2009, 09h26
ProgVal

Merci beaucoup à toi ;)

Ça m'évite sûrement des problèmes futurs...

Mais, il reste un truc qui me chiffonne: si l'objet est passé par référence, ça fait que la méthode peut modifier l'objet. Et c'est plus ou moins contraire à la philosophie objet, non?
19/09/2009, 09h43
Petibidon

Citation:

Envoyé par ProgVal

Mais, il reste un truc qui me chiffonne: si l'objet est passé par référence, ça fait que la méthode peut modifier l'objet. Et c'est plus ou moins contraire à la philosophie objet, non?

Bah justement non. Si une méthode doit modifier un objet c'est pas pour enfiler des perles. Si tu veux modifier une valeur sans modifier l'objet, tu récupères cette valeur et tu la traites.

Au pire si tu veux absolument traiter une copie de l'objet sans l'affecter, il faut que ta méthode le clone.

D'après le besoin, on en arriverait à un truc dans ce genre

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
 
<?php
  class FirstClass
  {
    private $_childs;
    private $_data;
 
    public __construct()
    {
      $childs = array();
    }
 
    public function SetData($data)
    {
      $this->_data=$data;
    }
 
    public function addChild(SecondClass $child)
    {
        $this->_child->setParent($this);
        $this->_childs[] = $child;
    }
 
  }
 
  class SecondClass
  {
    private $_parent;
 
    public function setParent(FirstClass $parent)
    {
      $this->_parent = $parent;
    }
 
    public function setDataAtTen()
    {
        $this->_parent->setData(10);
    }
  }

Si techniquement cela doit marcher, au niveau conception, c'est un peu bizarre. Ca fait une peu de références circulaires. Est-ce vraiment évolutif par la suite ?