|< C++ .NET Operator Overloading 7 | Main | Supplementary Note 2 >|

---

 

Supplementary Notes 1

Let Have A Break In Playing With Visual C++ .Net!

 

 

C++ Operators Operator Precedence and Associativity C++ Operator Precedence and Associativity Table Operator Overloading Overloadable Operators Non Overloadable Operators Example Overloaded Operators ---------------------------------------------- General Rules for Operator Overloading Example Implicit Boxing Example Explicitly Request Boxing Use gcnew to Create Value Types and Use Implicit Boxing Unboxing Standard Conversions and Implicit Boxing static Keyword Static Member Functions

 

 

C++ Operators

 

The following Table contains C++ operators organized by category.

 

 

Operator Precedence and Associativity

 

The C++ language includes all C operators and adds several new operators. Operators specify an evaluation to be performed on one of the following:

 

▪          One operand (unary operator).

▪          Two operands (binary operator).

▪          Three operands (ternary operator).

 

Operators follow a strict precedence, which defines the evaluation order of expressions containing these operators. Operators associate with either the expression on their left or the expression on their right; this is called "associativity." The following table shows the precedence and associativity of C++ operators (from highest to lowest precedence). Operators in the same segment of the table have equal precedence and are evaluated in the given order in an expression unless explicitly forced by parentheses.

 

C++ Operator Precedence and Associativity Table

 

 

Operator Overloading

 

The operator keyword declares a function specifying what operator-symbol means when applied to instances of a class. This gives the operator more than one meaning, or "overloads" it. The compiler distinguishes between the different meanings of an operator by examining the types of its operands.

 

type operator operator-symbol(parameter-list)

 

Example:

 

static bool operator==(const Operation^, const Operation^);

 

You can redefine the function of most built-in operators globally or on a class-by-class basis. Overloaded operators are implemented as functions. The name of an overloaded operator is operatorx, where x is the operator as it appears in the following table. For example, to overload the addition operator, you define a function called operator+. Similarly, to overload the addition/assignment operator, +=, define a function called operator+=.

 

Overloadable Operators

 

 

Note: Two versions of the unary increment and decrement operators exist: preincrement and postincrement.

 

Non Overloadable Operators

 

The operators shown in the following table cannot be overloaded. The table includes the preprocessor symbols # and ##.

 

 

Although overloaded operators are usually called implicitly by the compiler when they are encountered in code, they can be invoked explicitly the same way as any member or nonmember function is called:

 

Point pt;

pt.operator+(3);  // Call addition operator to add 3 to pt.

 

Example

 

The following traditional C++ code example overloads the + operator to add two complex numbers and returns the result.

 

// traditional C++ operator overloading

// compile with: /clr

#include "stdafx.h"

#include <iostream>

using namespace System;

using namespace std;

 

struct Complex

{

      Complex(double r, double i) : re(r), im(i) {}

      // Overloaded the addition...

      Complex operator+(Complex &other);

      void Display()

      {

            cout<<"Real part = "<<re<<", "<<"Imaginary part = "<<im<< endl;

      }

      private:

            double re, im;

};

 

// Operator overloaded using a member function

Complex Complex::operator+(Complex &other)

{

   return Complex(re + other.re, im + other.im);

}

 

int main()

{

   Complex a = Complex(1.2, 3.4);

   cout<<"a: ";

   a.Display();

   Complex b = Complex(5.6, 7.8);

   cout<<"b: ";

   b.Display();

   Complex c = Complex(0.0, 0.0);

   cout<<"c: ";

   c.Display();

   cout<<endl;

 

   c = a + b;

   cout<<"c = a + b: ";

   c.Display();

}

 

Output:

 

 

Overloaded Operators

 

Operator overloading has changed significantly from Managed Extensions for C++ to Visual C++ 2005. Perhaps the most striking aspect of Managed Extensions is its support for operator overloading or rather, its effective absence. Within the declaration of a reference type, for example, rather than using the native operator+ syntax, one has to explicitly write out the underlying internal name of the operator, in this case, op_Addition. More onerous, however, is the fact that the invocation of an operator has to be explicitly invoked through that name, thus precluding the two primary benefits of operator overloading:

 

1. The intuitive syntax, and
2. The ability to intermix new types with existing types.

 

For example:

 

// oper