Dynamic Binding.

[enki]

I have been doing some reading on dynamic bindind and polymorphism. I
know the basics from what I have seen in books. The way virtual
methods were explained was that they were used when methods the same
methods were inhereted into 2 objects and they are parents of new
objects.

I would like some situations where polymorphism is useful.
My next step will to try to understand handle classes.

[Alf P. Steinbach]

* enki:

I would like some situations where polymorphism is useful.

Try to make a simple arithmetic expression evaluator.

(This is one of my favorite examples.)

Don't bother with converting user input to expressions,
just create the expressions directly in code.

* An Expression has a member function eval() that produces
a double, the result of evaluating the expression.

* An Expression can be Number.

* An Expression can be a Sum of two Expressions.

* An Expression can be a Product of two Expressions.

The code
int main()
{
Expression* expr =
new Sum(
new Number( 2 ),
new Product( new Number( 3 ), new Number( 4 ) )
);

std::cout << expr->eval() << std::endl;
delete expr;
}
should write out the answer "14" and delete all objects new'ed.

(It's not exception safe, but don't bother with exception safety.)

--
A: Because it messes up the order in which people normally read text.
Q: Why is it such a bad thing?
A: Top-posting.
Q: What is the most annoying thing on usenet and in e-mail?

[PKH]

"enki" <en*****@yahoo.com> wrote in message
news:11**********************@f14g2000cwb.googlegr oups.com...

I have been doing some reading on dynamic bindind and polymorphism. I
know the basics from what I have seen in books. The way virtual
methods were explained was that they were used when methods the same
methods were inhereted into 2 objects and they are parents of new
objects.

I would like some situations where polymorphism is useful.
My next step will to try to understand handle classes.

Here's one: I got a project with several different object-types that needs
to be updated (run) on a regular basis, so I use
baseclasses such as this:

// baseclass for type-id
class CObjectID
{
public:
virtual CObjectID* GetClass(DWORD iId){return (iId == OID_OBJECTID) ? this :
NULL;}
};

// 'baseclass' for data-exchange
class CBaseContext : public CObjectID
{
public:
virtual bool Validate() = 0;
virtual CObjectID* GetClass(DWORD iId){return (iId == OID_BASECONTEXT) ?
this : CObjectID::GetClass(iId);}
};

// 'baseclass' for objects
class CTask : public CObjectID
{
private:
CTask
*m_pcParent;

CTaskList
m_cChildList;

public:
virtual void Run(CBaseContext* pcContext); // calls run on all
childtasks
virtual CObjectID* GetClass(DWORD iId){return (iId == OID_TASK) ? this :
CObjectID::GetClass(iId);}
};

Now I can build a tree of pointers to objects inherited from CTask, call Run
on the root and have all the objects updated (objects calls CTask::Run() in
their own Run() function to run it's own children).
When working mostly with pointers to baseclasses, a type-id system is
sometimes useful to enable checking the actual type of an object, or if an
object is inherited from a given class (esp. useful for for asserts() and
validation), so CTask inherits from CObjectID which has a virtual GetClass()
that gives this functionality.

PKH

[David White]

"enki" <en*****@yahoo.com> wrote in message
news:11**********************@f14g2000cwb.googlegr oups.com...

I have been doing some reading on dynamic bindind and polymorphism. I
know the basics from what I have seen in books. The way virtual
methods were explained was that they were used when methods the same
methods were inhereted into 2 objects and they are parents of new
objects.

I would like some situations where polymorphism is useful.

class DrawableObject
{
public:
virtual void draw(Surface &surface) = 0;
};

class Line : public DrawableObject
{
public:
// c'tor etc.
void draw(Surface &surface);
private:
// data member(s)
};

class Ellipse : public DrawableObject
{
public:
// ...
void draw(Surface &surface);
private:
// ...
};

// classes for other useful shapes

class CompositeDrawableObject : public DrawableObject
{
public:
// ...
void addComponent(DrawableObject *pComponent);
void draw(Surface &surface); // draws each component
private:
std::vector<DrawableObject*> mComponents;
};

// a function somewhere
void printAnObject(DrawableObject *pOb)
{
pOb->draw(GetPrinter().GetDrawSurface());
}

Imagine the different drawings that could be printed when printAnObject is
called, depending on what you pass to it. The actual class of the object
that pOb points to could be Line, Ellipse, or any other class derived from
DrawableObject. It could even be a class that didn't exist when
printAnObject was compiled. Now, suppose that pOb points to an object of
class CompositeDrawableObject. Then suppose that some components of that
CompositeDrawableObject are themselves CompositeDrawableObjects.

DW