Discussion :

[ProgVal]

Bonjour,

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[CR_Gio]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
    public function __construct(&$parameter)
    {
      $this->firstObjectPointer=&$parameter;
    }

Il faudrai écrire :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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,

[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).

[CR_Gio]

En réponse à :

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 php5 :

Sélectionner tout - Visualiser dans une fenêtre à part

$foo = new MaClass();

Exemple :
Soit la class Foo :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 PHP 4 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 PHP 5 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 PHP 4 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 PHP 5 :

Sélectionner tout - Visualiser dans une fenêtre à part

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^^

[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?

[Petibidon]

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.

[s.n.a.f.u]

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 ?