A C++ program examples showing Polymorphism, please help.

Dear CProgramming members and moderators,

Hello. A pleasant day to everyone, I hope everyone is doing okay upon reading this thread of mine. I'm currently (well, just reading a lillte) about polymorphism on C++, but I honestly find it difficult to understand sample programs especially on the Internet, I wondering (and requesting) if someone could give me at least four to five C++ example programs about polymorphism, with simple explanation on the workaround of the program. Well I just hope this is not too much to ask, just a very simple example and explanation will do.


Thank you for everyone who could share little C++ programs. Thank you very much.



Respectfully yours,

MarkSquall

Have you already tried searching this site with keywords "polymorphism" and/or "inheritance"?

Dear Dave_Sinkula ,

Good day to you Sir. I should say "Yes", I have tried searching for those keywords on the Internet, but then again the example they provided are somehow too advanced on my part; well I could admit that I don't open more site, so I guess I'll search for more sites about it. But, however, I really still hope that I could get some examples of you all members out there, because I know you all can explain the program to me in a friendly manner. Thanks again everyone.



Respectfully yours,

MarkSquall

Well, I kinda meant this site, as in http://cboard.cprogramming.com/searc...earchid=761509 such that perhaps we can all be on the same page without reinventing a couple wheels.

Simple example:

Code:

---

class A
{
public:
        virtual void foo();
};

class B: public A
{
public:
        virtual void foo();
};

int main()
{
        B b;
        A* p = dynamic_cast<A*>(&b);
        p->foo(); // Calls B.foo(), even though the pointer is A*
        return 0;
}

---

Dunno, compiles for me.

A little more accurately:

Code:

---

class A
{
public:
        virtual void foo();
};

class B : public A
{
public:
        virtual void foo();
};

int main()
{
        B b;
        A* p = &b;
        p->foo(); // Calls B.foo(), even though the pointer is A*
        return 0;
}

---

Quote:

---

Dunno, compiles for me.

---

But it does not demonstrate polymorphism. You are casting a pointer to a class B to a pointer to an unrelated class A.

A very simple polymorphism example:

Code:

---

void PrintHello()
{
    cout << "Hello\n";
}
void PrintHello(int n)
{
    for(int i=0; i<n; i++)
        cout << "Hello\n";
}

---

The two functions have the same name but do different things dependant on the parameters.

Quote:

---

Originally Posted by mike_g

A very simple polymorphism example:

Code:

---

void PrintHello()
{
    cout << "Hello\n";
}
void PrintHello(int n)
{
    for(int i=0; i<n; i++)
        cout << "Hello\n";
}

---

The two functions have the same name but do different things dependant on the parameters.

---

That is NOT polymorphism, but function overloading. A different concept all together.

--
Mats

Whoops. My bad.

Quote:

---

Originally Posted by laserlight

But it does not demonstrate polymorphism. You are casting a pointer to a class B to a pointer to an unrelated class A.

---

I think it's my time to say oops now :p
Of course, I forgot to derive B from A.
But with that done, it's definitely polymorphism, the concept of virtual functions.
Original post updated.

Quote:

---

Of course, I forgot to derive B from A.
But with that done, it's definitely polymorphism, the concept of virtual functions.

---

Yep.

Quote:

---

Original post updated.

---

I corrected your post with my reply earlier :)
You do not need dynamic_cast since B is-a A.

oh krap...in one of my interviews the interviewer said when a derived class is cast to a base class object, the base class's virtual function gets run. i admit i'm puerile enough to have fall for that!

Quote:

---

Originally Posted by jian2587

oh krap...in one of my interviews the interviewer said when a derived class is cast to a base class object, the base class's virtual function gets run. i admit i'm puerile enough to have fall for that!

---

So we can hope for one of two things:
1. That you get the job and can set them right.
2. That the interviewer isn't part of the design-team...

--
Mats

Quote:

---

Originally Posted by laserlight

Yep.

I corrected your post with my reply earlier :)
You do not need dynamic_cast since B is-a A.

---

Hehe, so you did. But still, it looks better if the original post is correct too, no? :)
At least it shows I incorporated the feedback and fixed the subtle bugs. And anyone who reads it won't get the wrong idea either!

I suppose you're right about the cast, as well... Come to think of it, otherwise we'd have to cast the pointer everytime we passed it to a function that took a pointer to reference to the base class...

Quote:

---

Originally Posted by jian2587

oh krap...in one of my interviews the interviewer said when a derived class is cast to a base class object, the base class's virtual function gets run. i admit i'm puerile enough to have fall for that!

---

Well, that's why the virtual keyword exists ;)
If you would omit the virtual, the base class's function would indeed be called. But when using virtual, the polymorphism is invoked and the compiler uses a virtual function table to call the correct function.

A more practical example of how polymorphism might be used is maybe like this.
You have a utility function that does a lot of work, presumably with an object. However, there are also lots of different types of that object. So the function can work from a base class and call virtual functions so the derived functions get called and do the correct work.
You might compare it to a car assembly. Here's some pseudo:

Code:

---

class Car
{
public:
        enum CarType { PART_MOTOR };
        virtual bool AddPart(CarType Type) = 0;
        virtual void Assemble() = 0;
};

class Ford: public Car
{
public:
        virtual bool AddPart(CarType Type);
        virtual void Assemble();
};

class Volvo: public Car
{
public:
        virtual bool AddPart(CarType Type);
        virtual void Assemble();
}

void AssembleCar(Car& car)
{
        // Assemble some parts into car
        car.AddPart(Car::PART_MOTOR);
        // Add some more parts
        // Finally, assembly everything
        car.Assemble();
}

int main()
{
        Volvo volvo;
        Ford ford;
        AssembleCar(volvo);
        AssembleCar(ford);
        return 0;
}

---

Since both cars wouldn't be assembled exactly the same, they can assemble themselves in their respective functions. This is an excellent example of how polymorphism is used.

well the interviewer didn't start out that way. She gave me codes in java, where a derived class overrides a function in the base class. She asked me if I invoke the overridden function of the derived class which is cast into its base class type, the base's or the derived's gets run. I said the derived's. She said good, then asked what if this is in C++. I said it'd be the same and she said NO, C++ works in the opposite way. I hereby seek enlightenment from you guys.

Code:

---

#include <iostream>
using namespace std;
class Base
{
public:
        int func_novirt();
        virtual int func_virt();
};

class Derived : public Base
{
public:
        int func_novirt();
        virtual int func_virt();
};

int Base::func_novirt (  )
{
        cout << "Base\n";
        return 0;
}

int Derived::func_novirt ( )
{
        cout << "derived\n";
        return 0;
}
int Base::func_virt (  )
{
        cout << "Base virtual\n";
        return 0;
}

int Derived::func_virt ( )
{
        cout << "derived virtual\n";
        return 0;
}


int main()
{
        Base b;
        Derived d;

        b.func_novirt ();
        d.func_novirt ();

        cout << "Virtuals\n";

        b.func_virt ();
        d. func_virt ();

        cout << "through base\n";
        Base *bp;
        bp = &b;
        bp->func_virt ();
        bp->func_novirt ();
        bp = &d;
        bp->func_virt ();
        bp->func_novirt ();

        return 0;
}

---

compile && run && study

Quote:

---

She asked me if I invoke the overridden function of the derived class which is cast into its base class type, the base's or the derived's gets run. I said the derived's. She said good, then asked what if this is in C++. I said it'd be the same and she said NO, C++ works in the opposite way. I hereby seek enlightenment from you guys.

---

The interviewer is correct. What she was asking about is type slicing, where an object of a derived class is cast to an object of its base class. Polymorphism in C++ works via pointers and references, so if she presented a case where a pointer to a derived class is cast to a pointer to the base class, then your answer would be correct.

This is an example that demonstrates type slicing and then polymorphic behaviour via a pointer:

Code:

---

#include <iostream>

class Base
{
public:
    virtual void foo() const
    {
        std::cout << "Base::foo()" << std::endl;
    }
};

class Derived : public Base
{
public:
    void foo() const
    {
        std::cout << "Derived::foo()" << std::endl;
    }
};

int main()
{
    Derived derived;

    static_cast<Base>(derived).foo(); // Cast from Derived to Base: type slicing occurs, so Base::foo() is called.

    Base* base_ptr = &derived; // Implicit cast from pointer to Derived to pointer to Base.
    base_ptr->foo();          // Polymorphism is used, so Derived::foo() is called.
}

---

I see. I actually tried writing similar codes to test it out but it didn't come out right. apparently there's one crucial difference. When coercing the derived into the base type I used explicit casting.

Thanks everyone again for the information. What makes really fun here is solving the problem I have in C/C++ programming together with everyone's help. I am really glad I come across to this site.


I have more questions to post here soon, so I hope everyone will be patient enough to teach me C and C++. God bless.


Respectfully Yours,

MarkSquall

P.S.
But how about Java? Is there a nice forum like this one about Java programming? Hope someone could share it too.