[PHP] verschil new en &new

[Verwijderd]

Hallo,

Weet iemand het verschil tussen new en &new bij het instantieren van een class?

Bijvoorbeeld:

PHP:

include_once("class.Myclass.php");
 $instance = new Myclass();

of:

PHP:

include_once("class.Myclass.php");
 $instance = &new Myclass();

Ik heb al flink gezocht, maar het is redelijk lastig om op keyword &new te zoeken, en aangezien ik niet weet of dit een bepaalde naam heeft.

Wat ik nu ongeveer denk te weten is dat het iets met geheugen adressen/bronnen is, maar goed, ik wacht op een beter antwoord

Kan iemand mij wijzer maken, met bronnen eventueel.

[Nielsz]

referenties

[.oisyn]

Zie reactie van Nielsz, de & heeft niets met new te maken, maar puur het feit dat ie de referentie van de expressie moet nemen ipv een kopie ervan

hetzelfde verschil als hier:

PHP:

$a = $b;   // kopie
$a = &$b;  // referentie


$a = new Blaat ();   // kopie
$a = &new Blaat ();  // referentie

[ Voor 13% gewijzigd door .oisyn op 17-02-2003 14:08 ]

[Joror]

quote: http://www.php.net/manual/en/language.oop.php

You *can* return a reference from a constructor. You just need to understand exactly what the "=" and "=&" operators do. Try this:

PHP:

class parent
{
  var $child;
  function parent($name)
  {
      $this->name = $name;
      $this->child =& new child($this);
}
}

class child
{
  var $parent;
  function child(&$parent)
  {
      $this->parent = &$parent;
  }
}

$p = new parent("a");
$p->child->parent->name="b";
echo "Name = $p->name\n";  // Prints "a"

$p =& new parent("a");
$p->child->parent->name="b";
echo "Name = $p->name\n"; // Prints "b"

***
It seems that when a class constructor is called, PHP creates a new instance of the class and then either hands back a reference to this instance if you use the =& assignment operator, or creates and hands back a whole new copy if you use the plain = assignment operator.

You should assign new instances with the =& operator unless you have a good reason not to, because it is faster.

[Verwijderd]

mm ik lees wel dit:

Note: There is no performance loss (since PHP 4 and up use reference counting) returning copies instead of references. On the contrary it is most often better to simply work with copies instead of references, because creating references takes some time where creating copies virtually takes no time (unless none of them is a large array or object and one of them gets changed and the other(s) one(s) subsequently, then it would be wise to use references to change them all concurrently).

Terwijl iemand beweerde dat dit heel veel uitmaakt

[stekkel]

Verwijderd schreef op 24 februari 2003 @ 11:02:
mm ik lees wel dit:


[...]


Terwijl iemand beweerde dat dit heel veel uitmaakt

hangt er vanaf hoe groot / complex je objecten zijn.

[.oisyn]

Verwijderd schreef op 24 February 2003 @ 11:02:
mm ik lees wel dit:
[...]
Terwijl iemand beweerde dat dit heel veel uitmaakt

Voor de performance maakt het misschien niet uit, maar waar die php-dorks niet aan denken is dat het wel eens incorrecte code kan opleveren. Als je met een kopie werkt en die wijzig je, dan wordt het andere kopie dat er van is niet meegewijzigd

voorbeeld:

PHP:

class Parent
{
    var $child;

    function Parent ()
    {
        $this->child = &new Child ($this);
    }
}

class Child
{
    var $parent;

    function Child (&$parent)
    {
        $this->parent = &$parent;
    }
}


$a = &new Parent ();  // ok, $a->child->parent wijst weer naar $a
$b = new Parent ();   // fout! $b->child->parent wijst niet naar $b

[sebas]

Dat vind ik een beetje een slap argument eigenlijk. Elk statement kan incorrecte code opleveren, als je met references werkt moet je er natuurlijk van uitgaan dat je precies weet wat je doet, dus een reference maak je aan als je een reference wilt, een copy als je een kopie moet hebben. Als het volledig uitwisselbaar was maakt het immers ook weinig zin om de programmeur hiermee op te zadelen. Al zijn er gevallen waar het verschil niet merkbaar is, tenminste waar het door de rest van de code niet uitmaakt of je een reference gebruikt of een copy, maar qua logica is het dus weldegelijk van belang.

http://cslibrary.stanford.edu/104/

Dit video is trouwens echt een aanrader als je wilt begripen hoe references / pointers werken (Er staat geen php voorbeeld in, d0h!, maar het geeft zeker een idee van wat waarom wel en niet werkt, en hoe.) Bovendien is het leuk