Operator overloading: Operátor túlterhelés PHP -ben

Ma egy érdekességgel készültem. Mégpedig a címben szereplő operátor túlterhelés bemutatásával. Azért csak érdekességnek és nem "hasznosságnak" hívom, mert a hozzá szükséges pecl kiterjesztés még nagyon is beta. Annyira, hogy csak erőszakkal lehet feltelepíteni. És 5.5-ös PHP-vel még nem kompatibilis.

Aki mondjuk programozott már C++ -ban vagy C#-ban, annak nem idegen a fogalom. A többiek kedvéért annyit, hogy ez egy lehetőség arra, hogy a nyelv beépített operátoraival megismertessük a saját, egyedi típusainkat, osztályainkat is. Így össze lehet adni egy Number típusú objektumot egy egész számmal például. Vagy az összeadás speciális jelentéssel bírhat, és hatására akár egy halmazt is bővíthetünk.

Telepítés

A használatához PHP-ben telepíteni kell az "operator" nevű pecl kiterjesztést.

  1. pecl install --force operator

A "--force" -ra azért van szükség, mert a telepítő látja, hogy ez nem egy stabil kiterjesztés. Így meg kell erősíteni, hogy komolyan gondoljuk.

A "pecl" program a php telepítési könyvtárában van a "bin" mappában. Egyedi telepítésnél, ha a program nincs a PATH változóban, a teljes útvonalát kell beírni.

Működése

Készíteni kell egy saját osztályt, amihez úgynevezett mágikus metódusokat kell definiálni. Ilyenek vannak az objektum tulajdonságainak lekérdezésére és még több más funkcióra is. A pecl kiterjesztés pedig további metódusokat ad.

Minden metódusban adott ugye az aktuális objektum. Az egyoperandusú műveleteknél nem is kell más. A $this változót használva az objektum állapota változtatható.

Kétoperandusú műveleteknél a baloldali operandus az aktuális objektum, a jobboldali pedig paraméterként jön. Ekkor van választási lehetőség, hogy az aktuális objektum állapotát változtatjuk meg a paraméter alapján vagy egy új objektumot hozunk létre és adjuk át visszatérési értékként.

Mivel az aktuális objektum a baloldali operandus, ebből adódik, hogy egy műveletnél baloldalon mindig olyan típusú objektumnak kell állnia, amire az operátorokat definiáljuk. Így, bár lehet konstans számot és objektumot összeadni, a sorrendre figyelni kell.

Bizonyos műveleteknél az egyik, másoknál a másik opció a jobb választás. Valamilyen visszatérési értéket viszont mindig célszerű adni, mivel így a műveletek láncolhatók. Azaz kettőnél több művelet hajtható végre egy utasításban. Erre mutatok majd példát, de a php beépített típusain végzett műveleteknél is ez történik.

Mágikus metódusok

Jelenleg az alábbi mágikus metódusok használhatók egy osztályban:

  1. /* +    */ public function __add($operand) {}
  2. /* -    */ public function __sub($operand) {}
  3. /* *    */ public function __mul($operand) {}
  4. /* /    */ public function __div($operand) {}
  5. /* %    */ public function __mod($operand) {}
  6.  
  7. /* <<   */ public function __sl($operand) {}
  8. /* >>   */ public function __sr($operand) {}
  9.  
  10. /* .    */ public function __concat($operand) {}  
  11.  
  12. /* |    */ public function __bw_or($operand) {}  
  13. /* &    */ public function __bw_and($operand) {}
  14. /* ^    */ public function __bw_xor($operand) {}  
  15. /* ~    */ public function __bw_not($operand) {}
  16.  
  17. /* ===  */ public function __is_identical($operand) {}
  18. /* !==  */ public function __is_not_identical($operand) {}
  19. /* ==   */ public function __is_equal($operand) {}
  20. /* !=   */ public function __is_not_equal($operand) {}
  21. /* <    */ public function __is_smaller($operand) {}
  22. /* <=   */ public function __is_smaller_or_equal($operand) {}
  23. //Igen, a > és >= nem támogatott
  24.  
  25. /* $i++ */ public function __post_inc($operand) {}
  26. /* $i-- */ public function __post_dec($operand) {}
  27. /* ++$i */ public function __pre_inc($operand) {}
  28. /* --$i */ public function __pre_dec($operand) {}
  29.  
  30. /* +=   */ public function __assign_add($operand) {}
  31. /* -=   */ public function __assign_sub($operand) {}
  32. /* *=   */ public function __assign_mul($operand) {}
  33. /* /=   */ public function __assign_div($operand) {}
  34. /* %=   */ public function __assign_mod($operand) {}
  35.  
  36. /* <<=  */ public function __assign_sl($operand) {}
  37. /* >>=  */ public function __assign_sr($operand) {}
  38.  
  39. /* .=   */ public function __assign_concat($operand) {}  
  40.  
  41. /* |=   */ public function __assign_bw_or($operand) {}  
  42. /* &=   */ public function __assign_bw_and($operand) {}
  43. /* ^=   */ public function __assign_bw_xor($operand) {}  

Mire jó, mikor használjam?

A bevezetőben említettem, hogy halmazműveleteket is lehet így végezni. Megspórolható pár metódushívás és átláthatóbb lehet a forráskód.

Másik eset, amikor adott egy függvénykönyvtár, mint a gmp, ami eleve nagy számokkal való munkához van, így adja magát a gondolat, hogy miért ne dolgozhatnánk vele operátorokkal.

De kellő fantáziával ennél extrémebb eseteket is ki lehet találni. Még családot is alapíthatunk. Ezt hamarosan kifejtem.

Példák

Egyszerű szám

  1. <?php
  2. class Number {
  3.   private $value = 0;
  4.  
  5.   public function __construct($number) {
  6.     $this->value = self::getOperandValue($number);
  7.   }
  8.  
  9.   public function getValue() {
  10.     return $this->value;
  11.   }
  12.  
  13.   public function __add($number) {
  14.     return new self($this->value + self::getOperandValue($number));
  15.   }
  16.  
  17.   private static function getOperandValue($value) {
  18.     if ($value instanceof self) {
  19.       $value = $value->value;
  20.     }
  21.     return $value;
  22.   }
  23.  
  24.   public function __toString() {
  25.     return strval($this->value);
  26.   }
  27. }
  28.  
  29. var_dump(new Number(15) + 5);

A getOperandValue metódust azért írtam, hogy tetszőleges típusokra működjön az összeadás. Persze, mint említettem, baloldalon csak Number típusú objektum állhat.

Látszik, hogy megmarad az objektum típus, mert azt adtuk visszatérési értékként, de megnő az értéke 5-tel. És persze a többi operátort is végig lehetne gépelni, de ezt most nem fogom. Inkább nézzük az érdekesebb példákat!

Halmaz

Talán pont halmazműveletekkel gyakoroltuk az egyetemen C++ -ban az operátortúlterhelést. Nézzük ezt PHP-ban:

  1. class Set {
  2.   private $value = array();
  3.  
  4.   public function __construct($value) {
  5.     if ($value instanceof self) {
  6.           $value = $value->getValue(); 
  7.         }
  8.        
  9.         if (is_array($value)) {
  10.                 $this->value = array_unique($value);
  11.         }
  12.   }
  13.  
  14.   public function __add($set) {
  15.     return new self(array_merge($this->value, self::getOperandValue($set)));
  16.   }
  17.  
  18.   private static function getOperandValue($value) {
  19.     if ($value instanceof self) {
  20.       $value = $value->value;
  21.     }
  22.     return $value;
  23.   }
  24. }
  25.  
  26. $A = new Set(array(1, 2, 3));
  27. $B = new Set(array(3, 4, 5));
  28.  
  29. var_dump($A+$B);

Ezzel összeadtam két halmazt. Kaptam egy harmadikat, aminek a metszetében csak a 3-as van. Így az eredményhalmaz az 1, 2, 3, 4, 5 elemeket tartalmazza egyszer. Most sem fogom a többi halmazműveletet megvalósítani. Mutatom inkább az utolsó és legérdekesebb példát.

Családalapítás

Eresszük el a fantáziánk és modellezzük le a családalapítást. Apu, anyu összebújik és az eredménye egy gyerek. Ennek a gyereknek automatikusan szülei lesznek apu és anyu. Nekik pedig egyre több gyerekük lesz.

  1. class Person { 
  2.   private $children = array();
  3.        
  4.   public function getChildren() {
  5.     return $this->children;
  6.   }
  7.  
  8.   public function addChild(Child $child) {
  9.     $this->children[strval($child)] = $child;
  10.   }
  11.  
  12.   public function __toString() {
  13.     return spl_object_hash($this);
  14.   }
  15. }
  16.  
  17. class Woman extends Person {
  18.   public function __sl(Man $man) {
  19.     $child = new Child(new Couple($this, $man));
  20.        
  21.         $man->addChild($child);
  22.         $this->addChild($child);
  23.         return $child;
  24.   }
  25. }
  26.  
  27. class Man extends Person {
  28.   public function __sr(Woman $woman) {
  29.     $child = new Child(new Couple($woman, $this));
  30.         $woman->addChild($child);
  31.         $this->addChild($child);
  32.         return $child;
  33.   }
  34. }
  35.  
  36. class Child extends Person {
  37.   private $parents = null;
  38.   public function __construct(Couple $parents) {
  39.     $this->parents = $parents;
  40.   }
  41.  
  42.   public function getParents() {
  43.     return $this->parents;
  44.   }
  45. }
  46.  
  47. class Couple {
  48.   private $man;
  49.   private $woman;
  50.   public function __construct(Woman $woman, Man $man) {
  51.     $this->man = $man;
  52.         $this->woman = $woman;
  53.   }
  54.   public function getMan() {
  55.     return $this->man;
  56.   }
  57.  
  58.   public function getWoman() {
  59.     return $this->woman;
  60.   }
  61. }
  62.  
  63. $woman = new Woman();
  64. $man = new Man();
  65.  
  66. echo "Gyerekek száma: ".count($woman->getChildren())."<br />";
  67. $child1 = $woman << $man;
  68. echo "Gyerekek száma: ".count($woman->getChildren())."<br />";
  69. $child2 = $man >> $woman;
  70. echo "Gyerekek száma: ".count($woman->getChildren())."<br />";
  71.  
  72. echo "Az első gyerek szülei: ";
  73. $parents = $child1->getParents();
  74. echo $parents->getWoman()." és ".$parents->getMan();

Persze a példa nem hibátlan, de aki unatkozik, ennél jobban is kidolgozhatja. Vagy találhat jobbat is.

GMP függvények

Végül pedig a gmp függvénykönyvtár néhány műveletét valósítom meg operátorokkal.

  1. <?php
  2. class GMPNumber  {
  3.   private $resource;
  4.   public function __construct($number) {
  5.     if (!is_resource($number)) {
  6.           $number = gmp_init($number);
  7.         }
  8.     $this->resource = $number;
  9.   }
  10.  
  11.   public function __add($number) {
  12.         return $this->_op('add', $number);
  13.   }
  14.  
  15.   public function __sub($number) {
  16.         return $this->_op('sub', $number);
  17.   }
  18.  
  19.   public function __mul($number) {
  20.     return $this->_op('mul', $number);
  21.   }
  22.  
  23.   public function __div($number) {
  24.         return $this->_op('div', $number);
  25.   }
  26.  
  27.   public function __mod($number) {
  28.         return $this->_op('mod', $number);
  29.   }
  30.    
  31.   private function _op($op, $number) {
  32.         return new self(call_user_func('gmp_'.$op, $this->resource, self::getOperandValue($number)));
  33.   }
  34.  
  35.   private static function getOperandValue($number) {
  36.     return strval($number);
  37.   }
  38.  
  39.   public function __toString() {
  40.         return gmp_strval($this->resource);
  41.   }
  42. }
  43.  
  44. $a = new GMPNumber('123');
  45. $b = new GMPNumber('110');
  46. ?>
  47. <pre>
  48. <?php echo ($a + $b); ?>
  49.  
  50. <?php echo $a - $b; ?>
  51.  
  52. <?php echo $a % new GMPNumber('2');?>
  53. </pre>

Vélemény

Meg lehet tehát lenni operátor túlterhelés nélkül, de akadhat olyan eset, amikor nagyon is jól jön, ha van. Éles szerverre azért talán nem telepíteném a kiterjesztést, de egy napon talán stabilabb lesz.

A példákat 5.4-es PHP alatt teszteltem. De elméletileg a korábbiakban is működik.

2013. augusztus 28.:

Az alábbi rfc bejegyzés szerint PHP 5.6-ban már tervezik a beépített megoldás megvalósítását. Az pedig már nincs messze, hiszen 5.5 a legfrissebb verzió.

PHP RFC: Internal operator overloading and GMP improvements

A példát pont a gmp-vel mutatják, de esküszöm, csak ma találtam meg :)

Források

Kategóriák: 
Megosztás/Mentés

Új hozzászólás