Chapter 13- Operator Overloading

Example-index1.cpp, Page no-470

In [1]:
class Index:
    __value=int
    def __init__(self):
        self.__value=0
    def GetIndex(self):
        return self.__value
    def NextIndex(self):
        self.__value=self.__value+1
idx1=Index()
idx2=Index()
print "Index1 =", idx1.GetIndex()
print "Index2 =", idx2.GetIndex()
idx1.NextIndex()
idx2.NextIndex()
idx2.NextIndex()
print "Index1 =", idx1.GetIndex()
print "Index2 =", idx2.GetIndex()

Index1 = 0
Index2 = 0
Index1 = 1
Index2 = 2

Example-index2.cpp, Page no-471

In [3]:
class Index:
    __value=int
    def __init__(self):
        self.__value=0
    def GetIndex(self):
        return self.__value
    #overload increment operator
    def __iadd__(self, op):
        self.__value=self.__value+op
        return self
idx1=Index()
idx2=Index()
print "Index1 =", idx1.GetIndex()
print "Index2 =", idx2.GetIndex()
idx1+=1 #overloaded increment operator invoked
idx2+=1 #overloaded increment operator invoked
idx2+=1 #overloaded increment operator invoked
print "Index1 =", idx1.GetIndex()
print "Index2 =", idx2.GetIndex()

Index1 = 0
Index2 = 0
Index1 = 1
Index2 = 2

Example-index3.cpp, Page no-475

In [1]:
class Index:
    __value=int
    def __init__(self):
        self.__value=0
    def GetIndex(self):
        return self.__value
    def __iadd__(self, op):
        self.__value+=1
        return self
idx1=Index()
idx2=Index()
print "Index1 =", idx1.GetIndex()
print "Index2 =", idx2.GetIndex()
idx2+=1
idx1+=1
idx2+=1
print "Index1 =", idx1.GetIndex()
print "Index2 =", idx2.GetIndex()

Index1 = 0
Index2 = 0
Index1 = 1
Index2 = 2

Example-index4.cpp, Page no-476

In [2]:
class Index:
    __value=int
    def __init__(self):
        self.__value=0
    def GetIndex(self):
        return self.__value
    #overload increment operator
    def __iadd__(self, op):
        self.__value=self.__value+op
        return self
idx1=Index()
idx2=Index()
print "Index1 =", idx1.GetIndex()
print "Index2 =", idx2.GetIndex()
idx1+=1
idx2+=1
idx2+=1
print "Index1 =", idx1.GetIndex()
print "Index2 =", idx2.GetIndex()

Index1 = 0
Index2 = 0
Index1 = 1
Index2 = 2

Example-index5.cpp, Page no-478

In [1]:
class Index:
    __value=int
    def __init__(self, val=0):
        self.__value=val
    def GetIndex(self):
        return self.__value
    #overload increment operator
    def __iadd__(self, op):
        self.__value=self.__value+op
        return self
idx1=Index(2)
idx2=Index(2)
idx3=Index()
idx4=Index()
print "Index1 =", idx1.GetIndex()
print "Index2 =", idx2.GetIndex()
idx3._Index__value=idx1._Index__value
idx1+=1
idx2+=1
idx4=idx2
print "Index1 =", idx1.GetIndex()
print "Index3 =", idx3.GetIndex()
print "Index2 =", idx2.GetIndex()
print "Index4 =", idx4.GetIndex()

Index1 = 2
Index2 = 2
Index1 = 3
Index3 = 2
Index2 = 3
Index4 = 3

Example-index6.cpp, Page no-479

In [1]:
class Index:
    __value=int
    def __init__(self, val=0):
        self.__value=val
    def GetIndex(self):
        return self.__value
    #overload increment operator
    def __iadd__(self, op):
        self.__value=self.__value+op
        return self
    #overload decrement operator
    def __isub__(self, op):
        self.__value=self.__value-op
        return self
    #overload negation operator
    def __neg__(self):
        return Index(-self.__value)
idx1=Index()
idx2=Index()
print "Index1 =", idx1.GetIndex()
print "Index2 =", idx2.GetIndex()
idx2+=1
idx1=-idx2
idx2+=1
idx2-=1
print "Index1 =", idx1.GetIndex()
print "Index2 =", idx2.GetIndex()

Index1 = 0
Index2 = 0
Index1 = -1
Index2 = 1

Example-mydate.cpp, Page no-480

In [1]:
class date:
    __day=int
    __month=int
    __year=int
    def __init__(self, d=0, m=0, y=0):
        if isinstance(d, int):
            self.__day=d
            self.__month=m
            self.__year=y
        else:
            self.__day=0
            self.__month=0
            self.__year=0
    def read(self):
        self.__day, self.__month, self.__year=[int(x) for x in raw_input("Enter date <dd mm yyyy>: ").split()]
    def show(self):
        print "%s:%s:%s" %(self.__day, self.__month, self.__year),
    def IsLeapYear(self):
        if (self.__year%4==0 and self.__year%100!=0) or (self.__year % 400==0):
            return 1
        else:
            return 0
    def thisMonthMaxDay(self):
        m=[31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
        if self.__month==2 and self.IsLeapYear():
            return 29
        else:
            return m[self.__month-1]
    def __iadd__(self, op): #overloading increment operator
        self.__day+=1
        if self.__day>self.thisMonthMaxDay():
            self.__day=1
            self.__month+=1
        if self.__month>12:
            self.__month=1
            self.__year+=1
        return self
def nextday(d):
    print 'Date', 
    d.show()
    d+=1 #overloaded increment operator invoked
    print "on increment becomes", 
    d.show()
    print ""
d1=date(14, 4, 1971)
d2=date(28, 2, 1992)
d3=date(28, 2, 1993)
d4=date(31, 12, 1995)
nextday(d1)
nextday(d2)
nextday(d3)
nextday(d4)
today=date()
today.read()
nextday(today)

Date 14:4:1971 on increment becomes 15:4:1971 
Date 28:2:1992 on increment becomes 29:2:1992 
Date 28:2:1993 on increment becomes 1:3:1993 
Date 31:12:1995 on increment becomes 1:1:1996 
Enter date <dd mm yyyy>: 11 9 1996
Date 11:9:1996 on increment becomes 12:9:1996

Example-complex1.cpp, Page no-483

In [1]:
def AddComplex(self, c2):
    temp=Complex()
    temp._Complex__real=self._Complex__real+c2._Complex__real
    temp._Complex__imag=self._Complex__imag+c2._Complex__imag
    return temp
class Complex:
    __real=float
    __imag=float
    def __init__(self):
        self.__real=self.__imag=0
    def getdata(self):
        self.__real=float(raw_input("Real part ? "))
        self.__imag=float(raw_input("Imag part ? "))
    AddComplex=AddComplex
    def outdata(self, msg):
        print "%s(%0.1f, %0.1f)" %(msg, self.__real, self.__imag)
c1=Complex()
c2=Complex()
c3=Complex()
print "Enter Complex Number c1..."
c1.getdata()
print "Enter Complex Number c2..."
c2.getdata()
c3=c1.AddComplex(c2)
c3.outdata("c3 = c1.AddComplex(c2) : ")

Enter Complex Number c1...
Real part ? 2.5
Imag part ? 2.0
Enter Complex Number c2...
Real part ? 3.0
Imag part ? 1.5
c3 = c1.AddComplex(c2) : (5.5, 3.5)

Example-complex2.cpp, Page no-484

In [3]:
def __add__(self, c2):
    temp=Complex()
    temp._Complex__real=self._Complex__real+c2._Complex__real
    temp._Complex__imag=self._Complex__imag+c2._Complex__imag
    return temp
class Complex:
    __real=float
    __imag=float
    def __init__(self):
        self.__real=self.__imag=0
    def getdata(self):
        self.__real=float(raw_input("Real part ? "))
        self.__imag=float(raw_input("Imag part ? "))
    #overloading + operator
    __add__=__add__
    def outdata(self, msg):
        print "%s(%0.1f, %0.1f)" %(msg, self.__real, self.__imag)
c1=Complex()
c2=Complex()
c3=Complex()
print "Enter Complex Number c1..."
c1.getdata()
print "Enter Complex Number c2..."
c2.getdata()
c3=c1+c2 #invoking the overloaded + operator
c3.outdata("c3 = c1 + c2: ")

Enter Complex Number c1...
Real part ? 2.5
Imag part ? 2.0
Enter Complex Number c2...
Real part ? 3.0
Imag part ? 1.5
c3 = c1 + c2: (5.5, 3.5)

Example-complex3.cpp, Page no-487

In [1]:
def __add__(self, c2):
    temp=Complex()
    temp._Complex__real=self._Complex__real+c2._Complex__real
    temp._Complex__imag=self._Complex__imag+c2._Complex__imag
    return temp
def __sub__(self, c2):
    temp=Complex()
    temp._Complex__real=self._Complex__real-c2._Complex__real
    temp._Complex__imag=self._Complex__imag-c2._Complex__imag
    return temp
def __mul__(self, c2):
    temp=Complex()
    temp._Complex__real=self._Complex__real*c2._Complex__real-self._Complex__imag*c2._Complex__imag
    temp._Complex__imag=self._Complex__real*c2._Complex__imag+self._Complex__imag*c2._Complex__real
    return temp
def __div__(self, c2):
    temp=Complex()
    qt=c2._Complex__real*c2._Complex__real+c2._Complex__imag *c2._Complex__imag
    temp._Complex__real=(self._Complex__real*c2._Complex__real+self._Complex__imag*c2._Complex__imag)/qt
    temp._Complex__imag=(self._Complex__imag*c2._Complex__real-self._Complex__real*c2._Complex__imag)/qt
    return temp
class Complex:
    __real=float
    __imag=float
    def __init__(self):
        self.__real=self.__imag=0
    def getdata(self):
        self.__real=float(raw_input("Real part ? "))
        self.__imag=float(raw_input("Imag part ? "))
    #overloading +, -, * and / operator
    __add__=__add__
    __sub__=__sub__
    __mul__=__mul__
    __div__=__div__
    def outdata(self, msg):
        print "%s(%g, %g)" %(msg, self.__real, self.__imag)
c1=Complex()
c2=Complex()
c3=Complex()
print "Enter Complex Number c1..."
c1.getdata()
print "Enter Complex Number c2..."
c2.getdata()
print "Entered Complex numbers are..."
c1.outdata("c1 = ")
c2.outdata("c2 = ")
print "Computational results are..."
c3=c1+c2 #invoking the overloaded + operator
c3.outdata("c3 = c1 + c2: ")
c3=c1-c2 #invoking the overloaded - operator
c3.outdata("c3 = c1 - c2: ")
c3=c1*c2 #invoking the overloaded * operator
c3.outdata("c3 = c1 * c2: ")
c3=c1/c2 #invoking the overloaded / operator
c3.outdata("c3 = c1 / c2: ")
c3 = c1 + c2 + c1 + c2
c3.outdata("c3 = c1 + c2 + c1 + c2: ")
c3 = c1 * c2 + c1 / c2
c3.outdata("c3 = c1 * c2 + c1 / c2: ")

Enter Complex Number c1...
Real part ? 2.5
Imag part ? 2.0
Enter Complex Number c2...
Real part ? 3.0
Imag part ? 1.5
Entered Complex numbers are...
c1 = (2.5, 2)
c2 = (3, 1.5)
Computational results are...
c3 = c1 + c2: (5.5, 3.5)
c3 = c1 - c2: (-0.5, 0.5)
c3 = c1 * c2: (4.5, 9.75)
c3 = c1 / c2: (0.933333, 0.2)
c3 = c1 + c2 + c1 + c2: (11, 7)
c3 = c1 * c2 + c1 / c2: (5.43333, 9.95)

Example-string.cpp, Page no-490

In [1]:
BUFF_SIZE=50
class string:
    __Str=[None]*BUFF_SIZE
    def __init__(self, MyStr=None):
        if isinstance(MyStr, str):
            self.__Str=MyStr
        else:
            self.__Str=""
    def echo(self):
        print self.__Str
    def __add__(self, s):
        temp=string(self._string__Str)
        temp._string__Str+=s._string__Str
        return temp
str1=string("Welcome to ")
str2=string("Operator Overloading")
str3=string()
print "Before str3 = str1 + str2;.."
print "str1 = ",
str1.echo()
print "str2 = ",
str2.echo()
print "str3 = ",
str3.echo()
str3=str1+str2
print "After str3 = str1 + str2;.."
print "str1 = ",
str1.echo()
print "str2 = ",
str2.echo()
print "str3 = ",
str3.echo()

Before str3 = str1 + str2;..
str1 =  Welcome to 
str2 =  Operator Overloading
str3 =  
After str3 = str1 + str2;..
str1 =  Welcome to 
str2 =  Operator Overloading
str3 =  Welcome to Operator Overloading

Example-idxcmp.cpp, Page no-491

In [1]:
(false, true)=(0, 1) #enum type
type =['false', 'true']
class Index:
    __value=int
    def __init__(self, val=0):
        self.__value=val
    def GetIndex(self):
        return self.__value
    #overloading < operator
    def __lt__(self, idx):
        return true if self.__value<idx.__value else false  #?: operator
idx1=Index(5)
idx2=Index(10)
print 'Index1 =', idx1.GetIndex()
print "Index2 =", idx2.GetIndex()
if idx1<idx2: #using the overloaded < operator
    print "Index1 is less than Index2"
else:
    print "Index1 is not less than Index2"

Index1 = 5
Index2 = 10
Index1 is less than Index2

Example-strcmp.cpp, Page no-493

In [1]:
(false, true)=(0, 1) #enum type
type =['false', 'true']
BUFF_SIZE=50
class string:
    __Str=[None]*BUFF_SIZE
    def __init__(self):
        self.__Str=""
    def read(self):
        self.__Str=raw_input()
    def echo(self):
        print self.__Str,
    #overloading < operator
    def __lt__(self, s):
        if self.__Str < s.__Str:
            return true
        else:
            return false
    #overloading > operator
    def __gt__(self, s):
        if self.__Str > s.__Str:
            return true
        else:
            return false
    #overloading == operator
    def __eq__(self, MyStr):
        if self.__Str ==MyStr:
            return true
        else:
            return false
str1=string()
str2=string()
while(1):
    print "Enter String1 <'end' to stop>:",
    str1.read()
    if str1=="end": #using overloaded == operator
        break
    print 'Enter String2:',
    str2.read()
    print 'Comparison status:',
    str1.echo()
    if str1<str2: #using overloaded < operator
        print "<",
    elif str1>str2:
        print ">", #using overloaded > operator
    else:
        print "=",
    str2.echo()
    print ""
print "Bye.!! That's all folks.!"

Enter String1 <'end' to stop>:C
 Enter String2:C++
 Comparison status: C < C++ 
Enter String1 <'end' to stop>:Rajkumar
 Enter String2:Bindu
 Comparison status: Rajkumar > Bindu 
Enter String1 <'end' to stop>:Rajkumar
 Enter String2:Venugopal
 Comparison status: Rajkumar < Venugopal 
Enter String1 <'end' to stop>:HELLO
 Enter String2:HELLO
 Comparison status: HELLO = HELLO 
Enter String1 <'end' to stop>:end
 Bye.!! That's all folks.!

Example-complex4.cpp, Page no-495

In [4]:
def __iadd__(self, c2):
    temp=Complex()
    temp._Complex__real=self._Complex__real+c2._Complex__real
    temp._Complex__imag=self._Complex__imag+c2._Complex__imag
    return temp
def __isub__(self, c2):
    temp=Complex()
    temp._Complex__real=self._Complex__real-c2._Complex__real
    temp._Complex__imag=self._Complex__imag-c2._Complex__imag
    return temp
def __imul__(self, c2):
    temp=Complex()
    temp._Complex__real=self._Complex__real*c2._Complex__real-self._Complex__imag*c2._Complex__imag
    temp._Complex__imag=self._Complex__real*c2._Complex__imag+self._Complex__imag*c2._Complex__real
    return temp
def __idiv__(self, c2):
    temp=Complex()
    qt=c2._Complex__real*c2._Complex__real+c2._Complex__imag *c2._Complex__imag
    temp._Complex__real=(self._Complex__real*c2._Complex__real+self._Complex__imag*c2._Complex__imag)/qt
    temp._Complex__imag=(self._Complex__imag*c2._Complex__real-self._Complex__real*c2._Complex__imag)/qt
    return temp
class Complex:
    __real=float
    __imag=float
    def __init__(self):
        self.__real=self.__imag=0
    def getdata(self):
        self.__real=float(raw_input("Real part ? "))
        self.__imag=float(raw_input("Imag part ? "))
    #overloading +=, -=, *= and /= operator
    __iadd__=__iadd__
    __isub__=__isub__
    __imul__=__imul__
    __idiv__=__idiv__
    def outdata(self, msg):
        print "%s(%g, %g)" %(msg, self.__real, self.__imag)
c1=Complex()
c2=Complex()
c3=Complex()
print "Enter Complex Number c1..."
c1.getdata()
print "Enter Complex Number c2..."
c2.getdata()
print "Entered Complex numbers are..."
c1.outdata("c1 = ")
c2.outdata("c2 = ")
print "Computational results are..."
c3=c1 
c3+=c2 #invoking the overloaded += operator
c3.outdata("let c3 = c1, c3+=c2: ")
c3=c1 
c3-=c2 #invoking the overloaded -= operator
c3.outdata("let c3 = c1, c3-=c2: ")
c3=c1 
c3*=c2 #invoking the overloaded *= operator
c3.outdata("let c3 = c1, c3*=c2: ")
c3=c1 
c3/=c2 #invoking the overloaded / operator
c3.outdata("let c3 = c1, c3/=c2: ")

Enter Complex Number c1...
Real part ? 2.5
Imag part ? 2.0
Enter Complex Number c2...
Real part ? 3.0
Imag part ? 1.5
Entered Complex numbers are...
c1 = (2.5, 2)
c2 = (3, 1.5)
Computational results are...
let c3 = c1, c3+=c2: (5.5, 3.5)
let c3 = c1, c3-=c2: (-0.5, 0.5)
let c3 = c1, c3*=c2: (4.5, 9.75)
let c3 = c1, c3/=c2: (0.933333, 0.2)

Example-complex-5.cpp, Page no-498

In [11]:
def __iadd__(self, c2):
    self._Complex__real=self._Complex__real+c2._Complex__real
    self._Complex__imag=self._Complex__imag+c2._Complex__imag
    return self
class Complex:
    __real=float
    __imag=float
    def __init__(self):
        self.__real=self.__imag=0
    def getdata(self):
        self.__real=float(raw_input("Real part ? "))
        self.__imag=float(raw_input("Imag part ? "))
    #overloading += operator
    __iadd__=__iadd__
    def outdata(self, msg):
        print "%s(%g, %g)" %(msg, self.__real, self.__imag)
c1=Complex()
c2=Complex()
c3=Complex()
print "Enter Complex Number c1..."
c1.getdata()
print "Enter Complex Number c2..."
c2.getdata()
c1 += c2 #using overloaded += operator
c3 = c1
print "On execution of c3 = c1 += c2.."
c1.outdata("Complex c1: ")
c2.outdata("Complex c2: ")
c3.outdata("Complex c3: ")

Enter Complex Number c1...
Real part ? 2.5
Imag part ? 2.0
Enter Complex Number c2...
Real part ? 3.0
Imag part ? 1.5
On execution of c3 = c1 += c2..
Complex c1: (5.5, 3.5)
Complex c2: (3, 1.5)
Complex c3: (5.5, 3.5)

Example-resource.cpp, Page no-499

In [1]:
ARRAY_SIZE=10
def read(self):
    for i in range(ARRAY_SIZE):
        print "vector[", i, "] = ? ",
        self._vector__array[i]=int(raw_input())
def sum(self):
    Sum=0
    for i in range(ARRAY_SIZE):
        Sum+=self._vector__array[i]
    return Sum
class vector:
    __array=[int]
    def new(self):
        myvector=vector()
        myvector.__array=[int]*ARRAY_SIZE
        return myvector
    def delete(self):
        del self
    read=read
    sum=sum
my_vector=vector()
my_vector=my_vector.new()
print "Enter Vector data..."
my_vector.read()
print "Sum of Vector =", my_vector.sum()
del my_vector

Enter Vector data...
vector[ 0 ] = ? 1
 vector[ 1 ] = ? 2
 vector[ 2 ] = ? 3
 vector[ 3 ] = ? 4
 vector[ 4 ] = ? 5
 vector[ 5 ] = ? 6
 vector[ 6 ] = ? 7
 vector[ 7 ] = ? 8
 vector[ 8 ] = ? 9
 vector[ 9 ] = ? 10
 Sum of Vector = 55

Example-meter.cpp, Page no-504

In [1]:
class Meter:
    __length=float
    def __init__(self, InitLength=0.0):
        self.__length=InitLength/100.0
    def float(self):
        LengthCms=self.__length*100.0
        return LengthCms
    def GetLength(self):
        self.__length=float(raw_input("Enter Length (in meters): "))
    def ShowLength(self):
        print "Length (in meter) =", self.__length
length1=float(raw_input("Enter Lenthg (in cms): "))
meter1=Meter(length1)
meter1.ShowLength()
meter2=Meter()
length2=float
meter2.GetLength()
length2=meter2.float()
print "Length (in cms) =", length2

Enter Lenthg (in cms): 150.0
Length (in meter) = 1.5
Enter Length (in meters): 1.669
Length (in cms) = 166.9

Example-strconv.cpp, Page no-506

In [1]:
BUFF_SIZE=50
class string:
    __Str=[None]*BUFF_SIZE
    def __init__(self, MyStr=None):
        if isinstance(MyStr, str):
            self.__Str=MyStr
        else:
            self.__Str=""
    def echo(self):
        print self.__Str
    def char(self):
        return self.__Str
msg="OOPs the Great"
str1=string(msg)
print "str1 =",
str1.echo()
str2=string("It is nice to learn")
receive=str2.char()
print "Str2 =", receive

str1 = OOPs the Great
Str2 = It is nice to learn

Example-d2r1.cpp, Page no-509

In [1]:
PI=3.141592654
class Radian:
    __rad=float
    def __init__(self, InitRad=0.0):
        self.__rad=InitRad
    def GetRadian(self):
        return self.__rad
    def Output(self):
        print "Radian =", self.GetRadian()
class Degree:
    __degree=float
    def __init__(self):
        self.__degree=0.0
    def Radian(self):
        return ( Radian(self.__degree * PI / 180.0))
    def Input(self):
        self.__degree=float(raw_input("Enter degree: "))
deg1=Degree()
deg1.Input()
rad1=deg1.Radian()
rad1.Output()

Enter degree: 180
Radian = 3.141592654

Example-d2r2.cpp, Page no-512

In [1]:
PI=3.141592654
class Degree:
    __degree=float
    def __init__(self):
        self.__degree=0.0
    def GetDegree(self):
        return self.__degree
    def Input(self):
        self.__degree=float(raw_input("Enter degree: "))
class Radian:
    __rad=float
    def __init__(self, deg=None):
        if isinstance(deg , Degree):
            self.__rad=deg.GetDegree()*PI/180.0
        else:
            self.__rad=0.0
    def GetRadian(self):
        return self.__rad
    def Output(self):
        print "Radian =", self.GetRadian()
deg1=Degree()
deg1.Input()
rad1=Radian(deg1)
rad1.Output()

Enter degree: 90
Radian = 1.570796327

Example-degrad.cpp, Page no-514

In [1]:
PI=3.141592654
class Radian:
    __rad=float
    def __init__(self, InitRad=0.0):
        self.__rad=InitRad
    def GetRadian(self):
        return self.__rad
    def Input(self):
        self.__rad=float(raw_input("Enter radian: "))
    def Output(self):
        print "Radian =", self.GetRadian()
class Degree:
    __degree=float
    def __init__(self, rad=None):
        if isinstance(rad, Radian):
            self.__degree=rad.GetRadian()*180.0/PI
        else:
            self.__degree=0.0
    def GetDegree(self):
        return self.__degree
    def Radian(self):
        return ( Radian(self.__degree * PI / 180.0))
    def Input(self):
        self.__degree=float(raw_input("Enter degree: "))
    def Output(self):
        print "Degree =", self.__degree
deg1=Degree()
deg1.Input()
rad1=deg1.Radian()
rad1.Output()
rad2=Radian()
rad2.Input()
deg2=Degree(rad2)
deg2.Output()

Enter degree: 180
Radian = 3.141592654
Enter radian: 3.142
Degree = 180.023339207

Example-script.cpp, Page no-516

In [1]:
from ctypes import Structure, c_int, c_char
class AccountEntry(Structure):
    _fields_=[('number',c_int), ('name', c_char*25)]
class AccountBook:
    __aCount=int
    __account=[AccountEntry]
    def __init__(self, aCountIn):
        self.__aCount=aCountIn
        for i in range(self.__aCount):
            self.__account.append(AccountEntry())
    def op(self, nameIn):
        if isinstance(nameIn, str):
            for i in range(self.__aCount):
                if nameIn==self.__account[i].name:
                    return self.__account[i].number
        elif isinstance(nameIn, int): #numberIn
            for i in range(self.__aCount):
                #print self.__account[i].number
                if nameIn==self.__account[i].number:
                    return self.__account[i].name
    def AccountEntry(self):
        for i in range(self.__aCount):
            self.__account[i].number=int(raw_input("Account Number: "))
            self.__account[i].name=raw_input("Account Holder Name: ")
accounts=AccountBook(5)
print "Building 5 Customers Database"
accounts.AccountEntry()
print "Accessing Accounts Information"
accno=int(raw_input("To access Name Enter Account Number: "))
print "Name:",accounts.op(accno) #accounts[accno]
name=raw_input("To access Account Number, Enter Name: ")
print "Account Number:",accounts.op(name) #accounts[name]

Building 5 Customers Database
Account Number: 1
Account Holder Name: Rajkumar
Account Number: 2
Account Holder Name: Kiran
Account Number: 3
Account Holder Name: Ravishanker
Account Number: 4
Account Holder Name: Anand
Account Number: 5
Account Holder Name: Sindhu
Accessing Accounts Information
To access Name Enter Account Number: 1
Name: Rajkumar
To access Account Number, Enter Name: Sindhu
Account Number: 5

Example-complex6.cpp, Page no-519

In [1]:
def readdata(self):
    self._Complex__real=float(raw_input("Real part ? "))
    self._Complex__imag=float(raw_input("Imag part ? "))
def outdata(self, msg):
    print "%s(%g, %g)" %(msg, self._Complex__real, self._Complex__imag)
class Complex:
    __real=float
    __imag=float
    def __init__(self):
        self.__real=self.__imag=0
    readdata=readdata
    outdata=outdata
    def __neg__(self):
        return neg(self)
#friend function overloading unary minus operator
def neg(c1):
    c=Complex()
    c._Complex__real=-c1._Complex__real
    c._Complex__imag=-c1._Complex__imag
    return c
c1=Complex()
c2=Complex()
print "Enter Complex Number c1..."
c1.readdata()
c2=-c1
c1.outdata("Complex c1 : ")
c2.outdata("Complex c2 = -Complex c1: ")

Enter Complex Number c1...
Real part ? 1.5
Imag part ? -2.5
Complex c1 : (1.5, -2.5)
Complex c2 = -Complex c1: (-1.5, 2.5)

Example-complex7.cpp, Page no-520

In [2]:
def readdata(self):
    self._Complex__real=float(raw_input("Real part ? "))
    self._Complex__imag=float(raw_input("Imag part ? "))
def outdata(self, msg):
    print "%s(%g, %g)" %(msg, self._Complex__real, self._Complex__imag)
class Complex:
    __real=float
    __imag=float
    def __init__(self):
        self.__real=self.__imag=0
    readdata=readdata
    outdata=outdata
    def __neg__(self):
        return neg(self)
#friend function overloading unary minus operator
def neg(c1):
    c1._Complex__real=-c1._Complex__real
    c1._Complex__imag=-c1._Complex__imag
c1=Complex()
print "Enter Complex Number c1..."
c1.readdata()
-c1
c1.outdata("Complex c1 : ")

Enter Complex Number c1...
Real part ? 1.5
Imag part ? -2.5
Complex c1 : (-1.5, 2.5)

Example-complex8.cpp, Page no-522

In [1]:
class Complex:
    __real=float
    __imag=float
    def __init__(self, realpart=0):
        if isinstance(realpart, float):
            self.__real=realpart
        self.__imag=0
    def readdata(self):
        self.__real=float(raw_input("Real part ? "))
        self.__imag=float(raw_input("Imag part ? "))
    def outdata(self, msg):
        print "%s(%g, %g)" %(msg, self.__real, self.__imag)
    def __add__(self, c2):
        return add(self, c2)
#friend function overloading + operator
def add(c1, c2):
    c=Complex()
    c._Complex__real=c1._Complex__real+c2._Complex__real
    c._Complex__imag=c1._Complex__imag+c2._Complex__imag
    return c
c1=Complex()
c2=Complex()
c3=Complex(3)
print "Enter Complex Number c1..."
c1.readdata()
print "Enter Complex Number c2..."
c2.readdata()
c3=c1+c2
c3.outdata("Result of c3 = c1 + c2: ")
c3=c1+Complex(2.0)
c3.outdata("Result of c3 = c1 + 2.0: ")
c3=Complex(3.0)+c2
c3.outdata("Result of c3 = 3.0 + c2: ")

Enter Complex Number c1...
Real part ? 1
Imag part ? 2
Enter Complex Number c2...
Real part ? 3
Imag part ? 4
Result of c3 = c1 + c2: (4, 6)
Result of c3 = c1 + 2.0: (3, 2)
Result of c3 = 3.0 + c2: (6, 4)

Example-complex9.cpp, Page no-525

In [1]:
class Complex:
    __real=float
    __imag=float
    def __init__(self, InReal=0):
        if isinstance(InReal, float):
            self.__real=InReal
            self.__imag=0
    def readdata(self):
        self.__real=float(raw_input("Real part ? "))
        self.__imag=float(raw_input("Imag part ? "))
    def outdata(self, msg):
        print "%s(%g, %g)" %(msg, self.__real, self.__imag)
    def __add__(self, c2):
        return add(self, c2)
#friend function overloading + operator
def add(c1, c2):
    c=Complex()
    c._Complex__real=c1._Complex__real+c2._Complex__real
    c._Complex__imag=c1._Complex__imag+c2._Complex__imag
    return c
c1=Complex()
c2=Complex()
c3=Complex(3)
print "Enter Complex Number c1..."
c1.readdata()
print "Enter Complex Number c2..."
c2.readdata()
c3=c1+c2
c3.outdata("Result of c3 = c1 + c2: ")
c3=c1+Complex(2.0)
c3.outdata("Result of c3 = c1 + 2.0: ")
c3=Complex(3.0)+c2
c3.outdata("Result of c3 = 3.0 + c2: ")

Enter Complex Number c1...
Real part ? 1
Imag part ? 2
Enter Complex Number c2...
Real part ? 3
Imag part ? 4
Result of c3 = c1 + c2: (4, 6)
Result of c3 = c1 + 2.0: (3, 2)
Result of c3 = 3.0 + c2: (6, 4)

Example-vector.cpp, Page no-528

In [1]:
def __assign__(self, v2):
    print "Assignment operation invoked"
    for i in range(v2._vector__size):
        self._vector__v[i]=v2._vector__v[i]
def show(self):
    for i in range(self._vector__size):
        print self.elem(i), ",",
class vector:
    __v=[int]
    __size=int
    def __init__(self, vector_size):
        if isinstance(vector_size, int):
            self.__size=vector_size
            self.__v=[int]*self.__size
        if isinstance(vector_size, vector):
            print "Copy constructor invoked"
            self.__size=vector_size.__size
            self.__v=[int]*self.__size
            for i in range(vector_size.__size):
                self.__v[i]=vector_size.__v[i]
    def __del__(self):
        del self.__v
    __assign__=__assign__
    def elem(self, i, x=None):
        if isinstance(x, int):
            if i>=self.__size:
                print "Error: Out of Range"
            self.__v[i]=x
        else:
            return self.__v[i]
    show=show
v1=vector(5)
v2=vector(5)
for i in range(5):
    v2.elem(i, i+1)
v1 = v2
v3 = vector(v2)
print "Vector v1:",
v1.show()
print "\nVector v2:",
v2.show()
print "\nVector v3:",
v3.show()

Copy constructor invoked
Vector v1: 1 , 2 , 3 , 4 , 5 , 
Vector v2: 1 , 2 , 3 , 4 , 5 , 
Vector v3: 1 , 2 , 3 , 4 , 5 ,

Example-mleak.cpp, Page no-530

In [1]:
vector=[int]*10
buffer=[chr]*6
for i in range(10):
    vector[i]=i+1
buffer="hello"
for i in range(10):
    print vector[i],
print "\nbuffer =", buffer
del vector

1 2 3 4 5 6 7 8 9 10 
buffer = hello

Example-misuse.cpp, Page no-533

In [1]:
class number:
    __num=int
    def read(self):
        self.__num=int(raw_input())
    def get(self):
        return self.__num
    def __add__(self, num2):
        Sum=number()
        Sum.__num=self.__num-num2.__num #subtraction instead of addition
        return Sum
num1=number()
num2=number()
Sum=number()
print "Enter Number 1: ",
num1.read()
print "Enter Number 2: ",
num2.read()
Sum=num1+num2 #addition of two numbers
print "sum = num1 + num2 =", Sum.get()

Enter Number 1: 5
 Enter Number 2: 10
 sum = num1 + num2 = -5

Example-1, Page no-537

In [1]:
def __add__(self, d2):
    temp_date=date()
    temp_date._date__sec=self._date__sec+d2._date__sec
    if(temp_date._date__sec>=60):
        temp_date._date__min+=1
        temp_date._date__sec=temp_date._date__sec-60
    temp_date._date__min=temp_date._date__min+self._date__min+d2._date__min
    if(temp_date._date__min>=60):
        temp_date._date__hr+=1
        temp_date._date__min=temp_date._date__min-60
    temp_date._date__hr=self._date__hr+d2._date__hr
    return temp_date
class date:
    __hr=int
    __min=int
    __sec=int
    def __init__(self, h=0, m=0, s=0):
        self.__hr=h
        self.__min=m
        self.__sec=s
    def show(self):
        print "%d hours, %d minutes, %d seconds" %(self.__hr, self.__min, self.__sec),
    __add__=__add__
date1=date(2, 4, 56)
date2=date(10, 59, 11)
date3=date()
date3=date1+date2
date1.show()
print "+",
date2.show()
print "=",
date3.show()

2 hours, 4 minutes, 56 seconds + 10 hours, 59 minutes, 11 seconds = 12 hours, 4 minutes, 7 seconds

Example-2, Page no-538

In [1]:
def __add__(self, b2):
    temp_basket=basket()
    temp_basket._basket__apples=self._basket__apples+b2._basket__apples
    temp_basket._basket__mangoes=self._basket__mangoes+b2._basket__mangoes
    return temp_basket
class basket:
    __apples=int
    __mangoes=int
    def __init__(self, a=0, m=0):
        self.__apples=a
        self.__mangoes=m
    def show(self):
        print self.__apples, " Apples and", self.__mangoes, " Mangoes"
    __add__=__add__ # overloading + operator
basket1=basket(7, 10)
basket2=basket(4, 5)
basket3=basket()
print "Basket 1 contains:"
basket1.show()
print "Basket 2 contains:"
basket2.show()
basket3=basket1+basket2 #using overloaded + operator
print "Adding fruits from Basket 1 and Basket 2 results in:"
basket3.show()

Basket 1 contains:
7  Apples and 10  Mangoes
Basket 2 contains:
4  Apples and 5  Mangoes
Adding fruits from Basket 1 and Basket 2 results in:
11  Apples and 15  Mangoes