Question

So suppose I have:

Class A
{
void A::DoSomething();
A::A()
};

Class B : public A
{
void B::DoSomething();
B::B()
}

Class C : public A
{
void C::DoSomething();
C::C()
}

B obj1;
C obj2;

void RemoveObjectFromListOrSomethingSimiliar(A objToLookFor)
{
//assuming you found the object, how would you call the top-level DoSomething() (for example B::DoSomething() ) instead of the A::DoSomething()?
}

I’m not sure if that makes sense

[EDIT]
Ok, so that’s kinda working. Though it’s still redirecting to the base method, which confuses me.

B obj1;
c obj2;
AList.push_back(obj1);
AList.push_back(obj2);

//later, in another method:

A objInBack = AList.back();
objInBack.DoSomething();

AList.pop_back();

The objInBack refers to the A-level of the class structure and subsequently calls that level of DoSomething(). I’ve changed A’s methods to virtual, so is there some way to explicitly define the level of execution or?

Answer 1

I’m not sure I got your question right, but I guess what you need is dynamic binding.

Here is an example based on your pseudocode.

#include <iostream>

class A
{
    public:
        A() {}
        virtual void DoSomething() { std::cout << "A did something!" << std::endl; }
};

class B : public A
{
    public:
        B() {}
        void DoSomething() { std::cout << "B did something!" << std::endl; }
};

class C : public A
{
    public:
        C() {}
        void DoSomething() { std::cout << "C did something!" << std::endl; }
};

void DoSomethingWithSomething(A* ptr)
{
    ptr->DoSomething();
}

int main()
{
    A* obj1 = new A();
    A* obj2 = new B();
    A* obj3 = new C();
    B* obj4 = new B();
    C* obj5 = new C();

    DoSomethingWithSomething(obj1);
    DoSomethingWithSomething(obj2);
    DoSomethingWithSomething(obj3);
    DoSomethingWithSomething(obj4);
    DoSomethingWithSomething(obj5);
}

The output would then be:

A did something!
B did something!
C did something!
B did something!
C did something!