partial polymorphism

What if I want a derived class to first execute the base class method and then its own method redefinition?

I tried the following but it didn't work

Code:

---


#include <iostream>

class Base_c
{
public:
    void vMethod(){std:: cout << "base" << std::endl;}
};

class Derived_c : public Base_c
{
    virtual void vMethod(){std::cout << "intermediate" << std::endl;}
};

class Derived_2_c : public Derived_c
{
    virtual void vMethod(){std::cout << "derived" << std::endl;}
};

int main()
{
      Base_c *b;
      Derived_2_c d;
      b = &d;
      b->vMethod();
}

---

i would like it to produce the (double) output
base
derived

it would be useful to handle both the base fields and the derived fuelds as well

I tiried this and it worked but could you suggest something else?

Code:

---

#include <iostream>

class Base_c
{
public:
    void vMethod(){std:: cout << "base" << std::endl;}
};

class Derived_c : public Base_c
{
public:
    virtual void vMethod(){std::cout << "intermediate" << std::endl;}
};

class Derived_2_c : public Derived_c
{
    virtual void vMethod(){std::cout << "derived" << std::endl;}
};


        Derived_c *b;
        Derived_2_c d;
        b = &d;
        ((Base_c*)b)->vMethod();
        b->vMethod();
       
        getchar();

---

Code:

---

#include <iostream>

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

class Derived: public Base
{
public:
    virtual void vMethod()
    {
        Base::vMethod();
        std::cout << "intermediate" << std::endl;
    }
};

int main()
{
      Derived d;
      Base& b = d;
      b.vMethod();
}

---

The base, the class to whose type you have a pointer to reference must have the function declared virtual. Otherwise the function won't be virtual.
You forgot to make the vMethod in derived public. It should be, since you are calling the vMethod.
By prefixing the name of the base class and "::", I can tell the compiler that the following function shall be in this namespace. So it pretty much tells the compiler to call the function vMethod in the base class.

Quote:

---

Originally Posted by Elysia

Code:

---

#include <iostream>

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

class Derived: public Base
{
public:
    virtual void vMethod()
    {
        Base::vMethod();
        std::cout << "intermediate" << std::endl;
    }
};

int main()
{
      Derived d;
      Base& b = d;
      b.vMethod();
}

---

---

great
sorry I am a newbie

You should also read up a little on polymorphism. After all, examples don't do justice and you need to learn what it actually does.

Quote:

---

Originally Posted by Elysia

You forgot to make the vMethod in derived public. It should be, since you are calling the vMethod.

---

but it worked (i tried it and i had the output
base
derived
)

Quote:

---

Originally Posted by Elysia

You should also read up a little on polymorphism. After all, examples don't do justice and you need to learn what it actually does.

---

could you suggest good links?

Quote:

---

Originally Posted by mynickmynick

but it worked (i tried it and i had the output
base
derived
)

---

probably it inherited the public propriety by Derived_c

Quote:

---

Originally Posted by mynickmynick

could you suggest good links?

---

http://cboard.cprogramming.com/showthread.php?t=74078

Quote:

---

Originally Posted by mynickmynick

probably it inherited the public propriety by Derived_c

---

Well, yes, it did, but then you overrode it with a private one, so it becomes private.
It is one of the things that is syntactically correct, but not semantically correct.
There was a thread about that some time ago... hrm...

Quote:

---

Originally Posted by mynickmynick

but it worked (i tried it and i had the output
base
derived
)

---

It worked, but compare the two codes. You have to cast to do what you want. That is not good. The point is to write something simple and to be clear. It would be simpler to have a method2 in the derived class rather than cast!

Your code works, because the intermediate class has two vMethods(). One from the base class (Base) and one from its own.
In other words, one Base::vMethod and one Derived::vMethod.
The compiler chooses the vMethod more "appropriate". It the pointer points to the Base class, then it uses the Base::Method. It at the derived it uses the Derived::vMethod.

Btw, public/private is enforced at compile time. Because the compiler sees that the type is Base, it checks in Base and sees that it is public, and so does not generate a compile error.
But in reality, Derived's method is called, which is private, which pretty much defies the purpose of those keywords.
Consider that, and why I suggested you add public to the derived class.

Quote:

---

Originally Posted by mynickmynick

What if I want a derived class to first execute the base class method and then its own method redefinition?

---

If it so happens that you want to call the base class' method from the derived class' method then Elysia's suggestion applies since it actually does that. On the other hand, if you always want to call the base class' method and then allow derived classes to do something extra, then you could use the non-virtual interface idiom, e.g.,

Code:

---

#include <iostream>

class Base
{
public:
    void method()
    {
        std::cout << "base" << std::endl;
        vMethod();
    }

    ~Base() {}
private:
    virtual void vMethod() {}
};

class Derived : public Base
{
private:
    virtual void vMethod()
    {
        std::cout << "derived" << std::endl;
    }
};

int main()
{
    Derived d;
    Base& b = d;
    b.method();
}

---

The member function that is made public and called in non-virtual, but a virtual member function provides a hook by which a derived class can do something extra. If there is an intermediate base class then you may have to add another hook method or resort to what Elysia suggested in the most derived class' method.

Note that the base class destructor is declared virtual. If you do not know why, then read the answer to this FAQ: When should my destructor be virtual?

Quote:

---

Originally Posted by mynickmynick

could you suggest good links?

---

Read this FAQ section: Inheritance — proper inheritance and substitutability

[QUOTE=laserlight;812545]If it so happens that you want to call the base ..
QUOTE]

thank you all

what if the arguments of the derived method change?

Then the derived method is no longer an override of the base method. For virtual functions, the arguments cannot change in C++.

(In type theory, they may change in specific ways, but C++ doesn't support this.)

If your design requires that your derived class must always call back to the base class, then you've implemented what is known as the Call super antipattern

If you follow the OP's description more closely, you'll see that the way he/she described the problem, it does sound more like it should be the base class calling a second pure-virtual method instead, which as it happens is the solution to the Call super antipattern.

Quote:

---

Originally Posted by iMalc

If you follow the OP's description more closely, you'll see that the way he/she described the problem, it does sound more like it should be the base class calling a second pure-virtual method instead, which as it happens is the solution to the Call super antipattern.

---

That is why I suggested the non-virtual interface idiom (or if you prefer, the Template Method pattern).

Quote:

---

Originally Posted by laserlight

That is why I suggested the non-virtual interface idiom (or if you prefer, the Template Method pattern).

---

i practically found it to be much better

Quote:

---

Originally Posted by laserlight

That is why I suggested the non-virtual interface idiom (or if you prefer, the Template Method pattern).

---

Oh you did too. Not sure how I missed that.

Quote:

---

Originally Posted by laserlight

Code:

---

#include <iostream>

class Base
{
public:
    void method()
    {
        std::cout << "base" << std::endl;
        vMethod();
    }

    ~Base() {}
private:
    virtual void vMethod() {}
};

class Derived : public Base
{
private:
    virtual void vMethod()
    {
        std::cout << "derived" << std::endl;
    }
};

int main()
{
    Derived d;
    Base& b = d;
    b.method();
}

---

......................
Note that the base class destructor is declared virtual.

---

I agree it must be virtual
but from the extract you proposed it seems you forgot to decalre it virtual?

Quote:

---

Originally Posted by mynickmynick

but from the extract you proposed it seems you forgot to decalre it virtual?

---

That's correct (or maybe it was merely a mix up in editing, but we'll never know). It was not my intention to leave out the virtual keyword.

Quote:

---

Originally Posted by laserlight

That's correct (or maybe it was merely a mix up in editing, but we'll never know). It was not my intention to leave out the virtual keyword.

---

thank you
what are the things to care for / pay attention when a desctructor is virtual? I mean what are the most common errors a newbie might make in that case?

Don't do virtual function calls within a destructor?

Don't forget to make the destructor virtual if the base class is to be used polymorphically?

ok
please give also other "must not do" examples you have experience of
thank you