Discussion :

[Bilhackmac]

Bonjour à tous,

Mon problème est simple mais je ne trouve pas la solution. J'aimerai pouvoir supprimer un objet (et donc appeler sa fonction __destruct()) alors que plusieurs référence lui sont rattachées.

J'utilise PHP 5.2.10

Puisqu'un bon bout de code vaux mieux qu'un long discours… si si!

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
 
class Object{
	public static $collection;
	protected $internal_uuid;
 
	public static function factory($uuid = null){
		if(isset(self::$collection[$uuid])){
			return self::$collection[$uuid];
		}else{
			return new Object();
		}
	}
 
	protected function __construct(){
		$this->uuid();
		/* Bon je vous copie pas tous le code mais en gros cette fonction affecte,
		* vous l'aurai compris, un identifiant unique a $this->internal_uuid.
		*/
 
		self::$collection[$this->internal_uuid] = $this;
	} 
 
	public function __destruct(){
		echo '__destruct';
	}
}
 
	//Après la déclaration de la classe, ben… on s'en sert.
$oObject = Object::factory();
unset($oObject);
echo '*** FIN DU SCRIPT ***';

L'exécution de ce bout de code nous donne :

Code :

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

1
2
3
 
*** FIN DU SCRIPT ***
__destruct

Ce qui est tout a fait normal car la référence à notre objet se trouve encore dans Object::collection après le unset et c'est donc a la fin de l'exécution du script que l'appel à __destruct se fait.

Ce que j'aimerai donc obtenir c'est :

Code :

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

1
2
3
 
__destruct
*** FIN DU SCRIPT ***

Avec Object::collection[<identifiant unique de mon instance>] == NULL juste après l'appel de unset($oObject)




Quelqu'un a-t-il une idée ? Je m'arrache les cheveux la dessus… j'ai essayé dans tous les sens avec référence, sans référence (bon même si elles sont implicite en PHP5)

[FredPsy]

Eh comme ça :

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
class Object{
    public static $collection;
    protected $internal_uuid;
 
    public static function factory($uuid = null){
        if(isset(self::$collection[$uuid])){
            return self::$collection[$uuid];
        }else{
            return new Object();
        }
    }
 
    protected function __construct(){
        $this->uuid();
        /* Bon je vous copie pas tous le code mais en gros cette fonction affecte,
        * vous l'aurai compris, un identifiant unique a $this->internal_uuid.
        */
 
        self::$collection[$this->internal_uuid] = $this;
    } 
 
    public function __destruct(){
        echo '*** FIN DU SCRIPT ***';
    }
}
 
    //Après la déclaration de la classe, ben… on s'en sert.
$oObject = Object::factory();
unset($oObject);

Le unset doit se trouver à la fin du code. Je pense que Php lit l'ensemble du code et le traite ensuite. Je ne sais pas si c'est cela mais il me semble bien.

[metagoto]

Quelqu'un a-t-il une idée ? Je m'arrache les cheveux la dessus… j'ai essayé dans tous les sens avec référence, sans référence (bon même si elles sont implicite en PHP5)

C'est tout à fait normal que ça ne se passe pas comme tu veux.
self::$collection garde une référence vers ton objet. Quand tu fais ton unset, la référence de $oObject est détruite, mais pas celle dans self::$collection.

Ton destructeur n'est donc appelé qu'à la toute fin du script, après le dernier echo.

Ce qu'il faudrait faire, c'est briser la première référence avant le unset.
Du genre:

Code :

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

1
2
3
public function release() {
  self::$collection[$this->internal_uuid] = null;
}

Puis:

Code :

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

1
2
3
$oObject = Object::factory();
$oObject->release();
unset($oObject);

Note que tu ne peux pas mettre l'équivalent de release() dans le destructeur car ce destructeur n'est pas appelé par unset(), mais bien par php à la toute fin.

[Herode]

Non, mais on peut quand même faire d'une pierre deux couilles :

Code :

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

1
2
3
4
5
6
7
class Object {
   public static function delete(Object $o) {
         self::$collection[$o->internal_uuid] = null;
         unset($o);
   }
   ...
}

et

Code :

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

1
2
$o = Object::factory();
Object::delete($o);

[Bilhackmac]

merci de vos réponse mais ce n'est pas exactement ce que je cherche. Ce que je voudrais c'est détruire l'objet à partir d'une ce ses références quelque soit le nombre de référence.

En partant de ma classe :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
$ref_x = $ref_y = $ref_z = $oObject = Object::factory();
unset($oObject);
 
var_dump($ref_x);
var_dump($ref_y);
var_dump($ref_z);
var_dump(Object::$collection[$uuid/*qui correspondrait à l'uuid de $oObject*/]);
 
/* Sortie écran */
NULL
NULL
NULL
NULL

Je ne sais pas si c'est réalisable en php5, s'il le faut je peux passé en php6.

[mathieu]

merci de vos réponse mais ce n'est pas exactement ce que je cherche. Ce que je voudrais c'est détruire l'objet à partir d'une ce ses références quelque soit le nombre de référence.

je n'ai pas compris, avec ton exemple de code, tu aurais aimé avoir quel résultat ?

[Bilhackmac]

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
 
class Object{
	public static $collection;
	protected $internal_uuid;
 
	public static function factory($uuid = null){
		if(isset(self::$collection[$uuid])){
			return self::$collection[$uuid];
		}else{
			return new Object();
		}
	}
 
	protected function __construct(){
		$this->uuid();
		/* Bon je vous copie pas tous le code mais en gros cette fonction affecte,
		* vous l'aurai compris, un identifiant unique a $this->internal_uuid.
		*/
 
		self::$collection[$this->internal_uuid] = $this;
	} 
 
	public function __destruct(){
		echo '__destruct';
	}
}
 
$ref_x = $ref_y = $ref_z = $oObject = Object::factory();
unset($oObject);
 
var_dump($ref_x);
var_dump($ref_y);
var_dump($ref_z);
var_dump(Object::$collection[$uuid/*qui correspondrait à l'uuid de $oObject*/]);

Avec ce code, et sans faire un unset sur chaque référence, j'aimerai avoir une sortie écran du type

Code :

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

1
2
3
4
5
6
 
__destruct
NULL
NULL
NULL
NULL

bien sur ce n'est pas ce que j'obtient actuellement


[edit] je voudrai que mes références se comportent comme des pointeurs en C++ (si mes base de c++ sont bonnes)

[Herode]

C'est possible mais malheureusement pas avec la même écriture qu'en C++.
La raison est présentée dans l'article du manuel sur les références :
http://www.php.net/manual/fr/languag...references.php

Autrement dit, pour obtenir le comportement que tu recherches, il faut recourir à une petite astuce d'écriture.

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 Objet{
    public $val = "aaa<br/>";
 
    public function __construct() {
        echo __METHOD__, "<br/>";
    }
 
    public function __destruct() {
        echo __METHOD__, "<br/>";
    }
 
    public function __toString() {
        return $this->val;
    }
}
 
$o = new Objet();
$ref = &$o;
$ref2 = &$ref;
echo "1, $o, $ref, $ref2, <br/>";
$o = null;
echo "1, $o, $ref, $ref2, <br/>";
echo "FIN SCRIPT";
?>

qui donne bien comme sortie

Code :

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

1
2
3
4
5
Objet::__construct
1, aaa, aaa, aaa, 
Objet::__destruct
1, , , , 
FIN SCRIPT

Malheureusement, la surcharge d'opérateurs qui est possible en C++ n'est pas présente en PHP, donc il n'y a pas moyen (à ma connaissance) d'implémenter ça de manière transparente dans ta classe.

[Bilhackmac]

Un grand merci Herode, grâce à tes lumières je peux désormais supprimer un objet quelque soit la référence par lequel on veux le supprimer.

J'ai tout de même dû modifier Object::factory car lors de la récupération d'un objet via Object::factory(<uuid de l'object>); il été impossible de supprimer cet objet via un unset ou un '= null'. Object::factory retourne donc systématiquement une référence du tableau statique Object::$collection au lieu de retourner 'new Object' dans le cas d'une création.


Voici la classe modifiée :

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
 
class Object{
	public $uuid;
 
	private static $collection = array();
 
 
 
	public static function &factory($uuid = null){
		if($uuid != null && isset(self::$collection[$uuid])){
			return self::$collection[$uuid];
		}else{
			$Object = new Object();
			return self::$collection[$Object->uuid];
		}
	}
 
	protected function __construct(){
		$this->uuid();
 
		self::$collection[$this->uuid] = $this;
	}
 
	public function __destruct(){
		echo __METHOD__;
	}
 
	final protected function uuid(){
		$md5 = md5(uniqid());
		$this->uuid = substr($md5, 0, 8) .'-'. substr($md5, 8, 4) .'-'. substr($md5, 12, 4) .'-'. substr($md5, 16, 4) .'-'. substr($md5, 20, 12);
	}
 
	public static function delete(Object $Object) {
		self::$collection[$Object->uuid] = null;
	}
}

On crée trois références :

Code :

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

1
2
3
4
 
$obj1 = &Object::factory();
$obj2 = &Object::factory($obj1->uuid);
$obj3 = &$obj1;

Puis on fait les tests :

Code :

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

1
2
3
4
5
6
7
8
9
 
/* Test 1 */
Object::delete($obj1);
 
/* Test 2 */
Object::delete($obj2);
 
/* Test 3 */
Object::delete($obj3);

Dans les 3 cas ont à bien $obj1 = $obj2 = $obj3 = null et Object::__destruct() est bien appelé après Object:delete();