我怎样才能让这个链表正常工作？

Question

I'm very new to linked lists and i can't seem to figure out why this isn't working.

The program doesn't crash and the compiler shows no errors but doActions() never runs.

This is the code for the function, it's called in the main loop.

void Action()
{
    clsParent* pCurrent;
    pCurrent = pHead;
    while(pCurrent != NULL)
    {
        clsPlayer* pPlayer;
        pPlayer = dynamic_cast<clsPlayer*>(pCurrent);
        if(pPlayer != NULL)
        {
            pPlayer->doActions();
        }
        pCurrent = pCurrent->pNext;
    }
}

This is supposed to call doActions() for every single player in the list (although there's only one).

doAction() worked perfectly fine before i tried to implement linked lists into the code so i know it isn't that. For those curious about what it does, it checks if the player is jumping and moves the player accordingly.

EDIT: I've noticed that i can put other functions in and it will work

This works:

void clsPlayer::jump()
{
    if(onGround)
    {
        jumping = true;
        yPos -= gravitySpeed;
        animationState = 3;
    }
}

While this doesn't

void clsPlayer::doActions()
{
    if(!onGround)
    {
        yPos += gravitySpeed;
    }

    if(jumping)
    {
        jumpTimeCounter++;
        yPos -= 20;
        if(jumpTimeCounter > 10)
        {
            jumping = false;
            jumpTimeCounter = 0;
        }
    }
}

Answer 1

pCurrent if of type clsParent or a subclass of it. The dynamic_cast to type clsPlayer will always fail and return null. Maybe there is a member data and you should use something like (the cast may even not be necessary):

clsPlayer* pPlayer;
pPlayer = dynamic_cast<clsPlayer*>(pCurrent->data);

Answer 2

From the code you posted I would offer you the following proposed solution:

template<T>
class ListNode
{
public:
    T* m_pNext;
};

class Base : public ListNode<Base>
{
public:
    Base();
    virtual ~Base();
    virtual void doActions() = 0;
};

class Derived1 : public Base
{
public:
    Derived1();
    virtual ~Derived1();
    virtual void doActions();
};

class Derived2 : public Base
{
public:
    Derived2();
    virtual ~Derived2();
    virtual void doActions();
};

void action()
{
    Base* pCurrent = pHead;
    while (pCurrent != NULL)
    {
        pCurrent->doActions();
        pCurrent = pCurrent->m_pNext;
    }
}

Things to note:

1. ListNode is a template class, and your base class (in your example, clsParent) inherits from it.
2. The base class declares doActions as a pure virtual function, so that derived classes may define their own specific implementation.
3. As a result of 1 & 2, notice that the loop to walk through the list and call the doActions method is simplified as we now avoid the cast.