Banking Problem

[ashu]

hi to all,
Please read the following ques. first.

assume that a bank maintains 2 kinds of accounts for
customers one called as
savings accounts & other as current account.
the savings account provides simple interest &
withdraw facilities but no check book facilities.
the current account provides check book facilities but
no interest.
current account holders should also maintain a minimum
balance and if the minimum balance falls below this
level a service charge is to be imposed.

create a class account that stores customers name,
account no & type of account
from this class derive the classes current acc &
savings acc. to make them more
specific to their environments. include necessary
member functions in order to achieve following tasks:
1. accept the deposit from the customer and compute
the balance
2. display the balance
3. compute and deposit the interest
4. permit the withdrawl and update the balance
5. check the minimun balance, impose penalty if
necessary &update the balance

-->>DO NOT USE CONSTRUCTORS AND USE MEMBER FUNCTIONS
TO INITIALIZE THE CLASS MEMBERS

(NOTE: #MAKE AN EXTRA FIELD DATE (INCLUDE DOS.H TO
ACCESS DATE STRUCTURE)
#MAKE THIS PROGRAM BY USING LINK LIST )
The problem i am facing is that when i have created two derived class
as directed, i have to create two linklist to each derived class. So at
the time of modifing, depositing or any other operation, i have to
search both the linklist, which will be very time consuming & if no
such account exist, it would be the worst of the worst case. Then i
think another solution, i make another derived class by taking (saving
& current class) early derived class as base class & create a single
linklist. Now, the problem in that is, when my account is saving type,
my current class in totally untouched(waste d) & vice-versa.
I want to make a single linklist by merging two linklist. Would anyone
suggest me the solution. The program should be Menu Driven.

Thank You

[Jim Langston]

"ashu" <as*********@gm ail.com> wrote in message
news:11******** **************@ f14g2000cwb.goo glegroups.com.. .

here, the object of base class can't access the member data & functions
of derived class, as inheritance not work in opposite direction, so
can't help.

Actually, it can. Here is a working program showing how using Run Time Type
Checking (RTTI). Polymorphism would be worthless otherwise.

#include <vector>
#include <iostream>
class Base
{
public:
virtual ~Base() {};
virtual void CommonFunc() = 0;
};

class Derived1 : Base
{
public:
~Derived1(){};
void D1Func() { std::cout << "Derived1" << std::endl; };
void CommonFunc() { std::cout << "Derived1 Common" << std::endl; };
};

class Derived2 : Base
{
public:
~Derived2 () {};
void D2Func() { std::cout << "Derived2" << std::endl; };
void CommonFunc() { std::cout << "Derived2 Common" << std::endl; };
};

int main()
{
std::vector<Bas e*> MyVector;
MyVector.push_b ack( (Base*) new Derived1 );
MyVector.push_b ack( (Base*) new Derived2 );
std::vector<Bas e*>::iterator it;
for ( it = MyVector.begin( ); it != MyVector.end(); ++it )
{
if ( dynamic_cast<De rived1*> (*it) != NULL )
dynamic_cast<De rived1*>(*it)->D1Func();
if ( dynamic_cast<De rived2*> (*it) != NULL )
dynamic_cast<De rived2*>(*it)->D2Func();
(*it)->CommonFunc() ;
}
char wait;
std::cin >> wait;
};

Output is:
Derived1
Derived1 Common
Derived2
Derived2 Common

[Jim Langston]

"Jim Langston" <ta*******@rock etmail.com> wrote in message
news:ov******** *******@fe03.lg a...

"ashu" <as*********@gm ail.com> wrote in message
news:11******** **************@ f14g2000cwb.goo glegroups.com.. .

here, the object of base class can't access the member data & functions
of derived class, as inheritance not work in opposite direction, so
can't help.

Actually, it can. Here is a working program showing how using Run Time
Type Checking (RTTI). Polymorphism would be worthless otherwise.

In addition to what I showed you, you should note that the
(*it).CommonFun c() didn't need to dynamic cast the object, because it would
call the function for whichever object was instatized since it was contained
in the base.

Basically you only have to do a dynamic_cast if you want to call a method
that only exists in a derived object, not the base. If the method exists in
the base just call it and it will use the derived's overriden method (if
there is one).

So if you didn't to use dynamic_casts you could enter "stubs" for all
methods that simply do nothing. Such as:

class Account
{
public:
virtual void CalcInterest() { }; // Default is do nothing
};

class Savings: Account
{
void CalcInterest() { Balace += Balance * 0.014; };
};

class Checking: Account
{
// Checking doesn't override CalcInterest()
};

So now when call:
(*it)->CalcInterest() ;

if the actual instance is Savings, nothing will happen as the base method
will be used which does nothing. If the instance is Checking the Balance
will be updated. Not dynamic_cast needed since the method CalcInterest()
exists in the base class.

[mlimber]

Jim Langston wrote:

"ashu" <as*********@gm ail.com> wrote in message
news:11******** **************@ f14g2000cwb.goo glegroups.com.. .

here, the object of base class can't access the member data & functions
of derived class, as inheritance not work in opposite direction, so
can't help.

Actually, it can. Here is a working program showing how using Run Time Type
Checking (RTTI). Polymorphism would be worthless otherwise.

I wouldn't say worthless. In fact, in my current project I use
polymorphism extensively but have RTTI disabled via a compiler switch
because my classes follow the more standard method of design described
by Karl above and don't need it.

#include <vector>
#include <iostream>
class Base
{
public:
virtual ~Base() {};
virtual void CommonFunc() = 0;
};

class Derived1 : Base
{
public:
~Derived1(){};
void D1Func() { std::cout << "Derived1" << std::endl; };
void CommonFunc() { std::cout << "Derived1 Common" << std::endl; };
};

class Derived2 : Base
{
public:
~Derived2 () {};
void D2Func() { std::cout << "Derived2" << std::endl; };
void CommonFunc() { std::cout << "Derived2 Common" << std::endl; };
};

int main()
{
std::vector<Bas e*> MyVector;
MyVector.push_b ack( (Base*) new Derived1 );
MyVector.push_b ack( (Base*) new Derived2 );
std::vector<Bas e*>::iterator it;
for ( it = MyVector.begin( ); it != MyVector.end(); ++it )
{
if ( dynamic_cast<De rived1*> (*it) != NULL )
dynamic_cast<De rived1*>(*it)->D1Func();
Better would be:

if( Derived1* p = dynamic_cast<De rived1*>(*it) )
{
p->D1Func();
}

Then, at least there's only one call to the non-trivial dynamic_cast.
if ( dynamic_cast<De rived2*> (*it) != NULL )
dynamic_cast<De rived2*>(*it)->D2Func();
(*it)->CommonFunc() ;
}
char wait;
std::cin >> wait;
};

Output is:
Derived1
Derived1 Common
Derived2
Derived2 Common

Cheers! --M

[Jim Langston]

"mlimber" <ml*****@gmail. com> wrote in message
news:11******** *************@g 49g2000cwa.goog legroups.com...

Jim Langston wrote:

"ashu" <as*********@gm ail.com> wrote in message
news:11******** **************@ f14g2000cwb.goo glegroups.com.. .

> here, the object of base class can't access the member data & functions
> of derived class, as inheritance not work in opposite direction, so
> can't help.
>

Actually, it can. Here is a working program showing how using Run Time
Type
Checking (RTTI). Polymorphism would be worthless otherwise.

I wouldn't say worthless. In fact, in my current project I use
polymorphism extensively but have RTTI disabled via a compiler switch
because my classes follow the more standard method of design described
by Karl above and don't need it.

Actually, my "Polymorphi sm would be worthless otherwise" was refering to the
fact that the member data & functions can be assess through a base pointer,
not to RTII. I had added the last sentance as an afterthough. Switch
sentances 2 and 3 around and it what I meant to say :D (IOW, I agree with
you)

if ( dynamic_cast<De rived1*> (*it) != NULL )
dynamic_cast<De rived1*>(*it)->D1Func();

Better would be:

if( Derived1* p = dynamic_cast<De rived1*>(*it) )
{
p->D1Func();
}

Then, at least there's only one call to the non-trivial dynamic_cast.

Agreed.