home *** CD-ROM | disk | FTP | other *** search
/ Reverse Code Engineering RCE CD +sandman 2000 / ReverseCodeEngineeringRceCdsandman2000.iso / RCE / Ebooks / Thinking in C++ V2 / C12 / Unary.cpp < prev   
Encoding:
C/C++ Source or Header  |  2000-05-25  |  3.4 KB  |  170 lines
  1. //: C12:Unary.cpp
  2. // From Thinking in C++, 2nd Edition
  3. // Available at http://www.BruceEckel.com
  4. // (c) Bruce Eckel 1999
  5. // Copyright notice in Copyright.txt
  6. // Overloading unary operators
  7. #include <iostream>
  8. using namespace std;
  9.  
  10. class Integer {
  11.   long i;
  12.   Integer* This() { return this; }
  13. public:
  14.   Integer(long ll = 0) : i(ll) {}
  15.   // No side effects takes const& argument:
  16.   friend const Integer&
  17.     operator+(const Integer& a);
  18.   friend const Integer
  19.     operator-(const Integer& a);
  20.   friend const Integer
  21.     operator~(const Integer& a);
  22.   friend Integer*
  23.     operator&(Integer& a);
  24.   friend int
  25.     operator!(const Integer& a);
  26.   // Side effects don't take const& argument:
  27.   // Prefix:
  28.   friend const Integer&
  29.     operator++(Integer& a);
  30.   // Postfix:
  31.   friend const Integer
  32.     operator++(Integer& a, int);
  33.   // Prefix:
  34.   friend const Integer&
  35.     operator--(Integer& a);
  36.   // Postfix:
  37.   friend const Integer
  38.     operator--(Integer& a, int);
  39. };
  40.  
  41. // Global operators:
  42. const Integer& operator+(const Integer& a) {
  43.   cout << "+Integer\n";
  44.   return a; // Unary + has no effect
  45. }
  46. const Integer operator-(const Integer& a) {
  47.   cout << "-Integer\n";
  48.   return Integer(-a.i);
  49. }
  50. const Integer operator~(const Integer& a) {
  51.   cout << "~Integer\n";
  52.   return Integer(~a.i);
  53. }
  54. Integer* operator&(Integer& a) {
  55.   cout << "&Integer\n";
  56.   return a.This(); // &a is recursive!
  57. }
  58. int operator!(const Integer& a) {
  59.   cout << "!Integer\n";
  60.   return !a.i;
  61. }
  62. // Prefix; return incremented value
  63. const Integer& operator++(Integer& a) {
  64.   cout << "++Integer\n";
  65.   a.i++;
  66.   return a;
  67. }
  68. // Postfix; return the value before increment:
  69. const Integer operator++(Integer& a, int) {
  70.   cout << "Integer++\n";
  71.   Integer r(a.i);
  72.   a.i++;
  73.   return r;
  74. }
  75. // Prefix; return decremented value
  76. const Integer& operator--(Integer& a) {
  77.   cout << "--Integer\n";
  78.   a.i--;
  79.   return a;
  80. }
  81. // Postfix; return the value before decrement:
  82. const Integer operator--(Integer& a, int) {
  83.   cout << "Integer--\n";
  84.   Integer r(a.i);
  85.   a.i--;
  86.   return r;
  87. }
  88.  
  89. void f(Integer a) {
  90.   +a;
  91.   -a;
  92.   ~a;
  93.   Integer* ip = &a;
  94.   !a;
  95.   ++a;
  96.   a++;
  97.   --a;
  98.   a--;
  99. }
  100.  
  101. // Member operators (implicit "this"):
  102. class Byte {
  103.   unsigned char b;
  104. public:
  105.   Byte(unsigned char bb = 0) : b(bb) {}
  106.   // No side effects: const member function:
  107.   const Byte& operator+() const {
  108.     cout << "+Byte\n";
  109.     return *this;
  110.   }
  111.   const Byte operator-() const {
  112.     cout << "-Byte\n";
  113.     return Byte(-b);
  114.   }
  115.   const Byte operator~() const {
  116.     cout << "~Byte\n";
  117.     return Byte(~b);
  118.   }
  119.   Byte operator!() const {
  120.     cout << "!Byte\n";
  121.     return Byte(!b);
  122.   }
  123.   Byte* operator&() {
  124.     cout << "&Byte\n";
  125.     return this;
  126.   }
  127.   // Side effects: non-const member function:
  128.   const Byte& operator++() { // Prefix
  129.     cout << "++Byte\n";
  130.     b++;
  131.     return *this;
  132.   }
  133.   const Byte operator++(int) { // Postfix
  134.     cout << "Byte++\n";
  135.     Byte before(b);
  136.     b++;
  137.     return before;
  138.   }
  139.   const Byte& operator--() { // Prefix
  140.     cout << "--Byte\n";
  141.     --b;
  142.     return *this;
  143.   }
  144.   const Byte operator--(int) { // Postfix
  145.     cout << "Byte--\n";
  146.     Byte before(b);
  147.     --b;
  148.     return before;
  149.   }
  150. };
  151.  
  152. void g(Byte b) {
  153.   +b;
  154.   -b;
  155.   ~b;
  156.   Byte* bp = &b;
  157.   !b;
  158.   ++b;
  159.   b++;
  160.   --b;
  161.   b--;
  162. }
  163.  
  164. int main() {
  165.   Integer a;
  166.   f(a);
  167.   Byte b;
  168.   g(b);
  169. } ///:~
  170.