C++ allows the programmer to associate specific functionality of a class with the standard predefined operators, such as '+','-','=','==' etc. One class which demonstrates the use of these over-loaded operators is the String class, which associates the '+' with concatenation, '=' to assignment etc. We can over-load the predefined operators to suit our own classes

For example, in the Account class we can add a + operator, allowing Account objects to be summed in an appropriate way. For example:

 1 
 2 // Operator Overloaded Account Example
 3  
 4 #include<iostream>
 5 #include<string>
 6  
 7 using namespace std;
 8  
 9 class Account{
10 
11   protected:
12 
13     int accountNumber;
14     float balance;
15     string owner;
16 
17   public:
18 
19     Account(string owner, float aBalance, int anAccountNumber);
20     Account(float aBalance, int anAccountNumber);
21     Account(int anAccountNumber);
22 
23     Account operator + (Account);
24     bool operator == (Account);
25 
26     virtual void display();
27     virtual void makeLodgement(float);
28     virtual void makeWithdrawal(float);
29 };
30 
31 Account::Account(string anOwner, float aBalance, int anAccNumber):
32 	accountNumber(anAccNumber), balance(aBalance),
33 	owner (anOwner) {}
34 
35 Account::Account(float aBalance, int anAccNumber) :
36 	accountNumber(anAccNumber), balance(aBalance),
37 	owner ("Not Defined") {}
38 
39 Account::Account(int anAccNumber):
40 	accountNumber(anAccNumber), balance(0.0f),
41 	owner ("Not Defined") {}
42 
43 Account Account::operator + (Account a)
44 {
45     return Account(owner, balance + a.balance, accountNumber);
46 }
47 
48 bool Account::operator == (Account a)
49 {
50     if ((a.balance == balance) && (a.owner == owner) && 
51 		(a.accountNumber == accountNumber))
52     { return true; }
53     else return false;
54 }
55 
56 
57 void Account::display(){;
58     cout << "account number: " << accountNumber
59       << " has balance: " << balance << " Euro" << endl;
60     cout << "This account is owned by: " << owner << endl;
61 }
62 
63 void Account::makeLodgement(float amount){
64     balance = balance + amount;
65 }
66 
67 void Account::makeWithdrawal(float amount){
68     balance = balance - amount;
69 }
70  
71 int main()
72 {
73   Account a = Account(10.50, 123456);  
74   a.display();
75 
76   Account b = Account("Derek Molloy", 35.50, 123457);  
77   b.display();
78 
79   Account c = Account("Derek Molloy", 35.50, 123457);    
80   if (b == c) { cout << "b and c are equal!" << endl; }
81 
82   Account d = b + a;
83   d.display();
84 }
85 
86 

The full source code for this example is in OperatorOverloadAccount.cpp

In this example the + operator has been over-loaded to add the balance of the object on the RHS of the + to the object on the LHS. It does not add the accountNumber or the owner states (as this would not make sense). The method creates a new Account object and returns it from the method. This is assigned to con the LHS of the assignment, when Account d = b + a; is executed. The output from this code is:

 
 C:\My Documents\My Teaching\EE402 Notes\source_notes\cpp>
 OperatorOverloadAccount
 
 account number: 123456 has balance: 10.5 Euro
 This account is owned by: Not Defined
 account number: 123457 has balance: 35.5 Euro
 This account is owned by: Derek Molloy
 b and c are equal!
 account number: 123457 has balance: 46 Euro
 This account is owned by: Derek Molloy

 C:\My Documents\My Teaching\EE402 Notes\source_notes\cpp>

In the line of code:

	Account d = b + a;

We can look at the statement as two stages. In the first stage b + a is called. Imagine that the + operator was replaced by an add() method. You would call b.add(a)to add an Account object a to an Account object b. Well the + operator is exactly like this - you can think of it as b.+(a) if you like. Now in my example, rather than add the object a to b, I allowed the method to create a new object. So, the first element passed to the operator is the object you are operating on, and the second element is the parameter that you are passing.

In the second stage d = (b + a); the assignment sets the LHS to be equal to the new object returned from the + method.

The reason that the + method has full access to the private data of the Account object a that was passed as a parameter is because the code was written inside the Account class, therefore, having full private access to the states of the Account class.

In this example the == operator allows a comparison of two Account objects, by comparing the states of the objects to see if they are equal. It is up to the programmer to decide what defines objects that are equal. For example, in the Account you may decide that two Account objects are equal if the owner and balance are the same, or you may also require that the accountNumber states are also equal. The == operator can therefore have specific implementation in different classes.