Surcharge d'opérateur & héritage

<section id="14.9">
<title>
Surcharge d'opérateur &amp;
héritage</title>

<paragraph>A part l'opérateur d'assignation, les opérateurs sont automatiquement hérités dans une classe dérivée. Ceci peut se
démontrer en héritant de <b>C12:Byte.h</b>:</paragraph>

<code langage="cpp">//: C14:OperatorInheritance.cpp
// Hériter des opérateurs surchargés
#include "../C12/Byte.h"
#include &lt;fstream&gt;
using namespace std;
ofstream out("ByteTest.out");

class Byte2 : public Byte {
public:
  // Les constructeurs ne s'héritent pas :
  Byte2(unsigned char bb = 0) : Byte(bb) {}  
  // opérateur = ne s'hérite pas, mais 
  // est fabriqué pour les assignations liées aux membres.
  // Toutefois, seul l'opérateur SameType = SameType
  // est fabriqué, et vous devez donc
  // fabriquer les autres explicitement :
  Byte2&amp; operator=(const Byte&amp; right) {
    Byte::operator=(right);
    return *this;
  }
  Byte2&amp; operator=(int i) { 
    Byte::operator=(i);
    return *this;
  }
};

// Fonction test similaire à celle contenue dans C12:ByteTest.cpp:
void k(Byte2&amp; b1, Byte2&amp; b2) {
  b1 = b1 * b2 + b2 % b1;

  #define TRY2(OP) \
    out &lt;&lt; "b1 = "; b1.print(out); \
    out &lt;&lt; ", b2 = "; b2.print(out); \
    out &lt;&lt; ";  b1 " #OP " b2 produces "; \
    (b1 OP b2).print(out); \
    out &lt;&lt; endl;

  b1 = 9; b2 = 47;
  TRY2(+) TRY2(-) TRY2(*) TRY2(/)
  TRY2(%) TRY2(^) TRY2(&amp;) TRY2(|)
  TRY2(&lt;&lt;) TRY2(&gt;&gt;) TRY2(+=) TRY2(-=)
  TRY2(*=) TRY2(/=) TRY2(%=) TRY2(^=)
  TRY2(&amp;=) TRY2(|=) TRY2(&gt;&gt;=) TRY2(&lt;&lt;=)
  TRY2(=) // Assignment operator

  // Instructions conditionnelles :
  #define TRYC2(OP) \
    out &lt;&lt; "b1 = "; b1.print(out); \
    out &lt;&lt; ", b2 = "; b2.print(out); \
    out &lt;&lt; ";  b1 " #OP " b2 produces "; \
    out &lt;&lt; (b1 OP b2); \
    out &lt;&lt; endl;

  b1 = 9; b2 = 47;
  TRYC2(&lt;) TRYC2(&gt;) TRYC2(==) TRYC2(!=) TRYC2(&lt;=)
  TRYC2(&gt;=) TRYC2(&amp;&amp;) TRYC2(||)

  // Assignation en chaîne :
  Byte2 b3 = 92;
  b1 = b2 = b3;
}

int main() {
  out &lt;&lt; "member functions:" &lt;&lt; endl;
  Byte2 b1(47), b2(9);
  k(b1, b2);
} ///:~</code>

<paragraph>Le code test est identique à celui utilisé dans <b>C12:ByteTest.cpp</b> sauf que <b>Byte2</b> est utilisé à la place de
<b>Byte</b>. De cette façon, on vérifie que tous les opérateurs fonctionnent avec <b>Byte2</b> via l'héritage.</paragraph>
<paragraph>Quand vous examinez la classe <b>Byte2</b>, vous constatez que le constructeur doit être explicitement défini, et que, seul, 
<b>operator=</b> qui assigne un <b>Byte2</b> à un <b>Byte2</b> est fabriqué ; tout autre opérateur d'assignation dont vous avez besoin
devra être fabriqué par vos soins.</paragraph>
</section>