PS:
mit std::list und std::string kann man den code vermutlich in 5-10 zeilen schreiben...

Ich muss das ganze in einer VM (Linux) compilieren und dann auf meinen Gameserver hochladen.

umso mehr ein Grund std::string, std::list und auch noch Konstruktoren nebst Initialisierungslisten zu verwenden. Dann kann der Code schon (fast) nicht mehr crashen.

In RemovePlayer müssen auch die next-Zeiger umgehängt werden. Da Du das unterlässt und nur die Elemente löscht (eigentlich wird nur pStart gelöscht!?) zeigen die anderen next-Pointer irgendwann auf nicht allozierten Speicher und dann crashed es ganz automatisch.

Tipp: mache den Kopie-Konstruktor und den Zuweisungsoperator von CPlayer private.

Gruß
Werner

Hä, wie meinst du das? Sorry, ich komme gerade nicht mit...

Zeichne dir aus was dein RemovePlayer macht. (bedenke dabei wie die Node aussieht die vor der zu loeschenden Node steht)

Aber mal ehrlich: wenn du den Code produktiv einsetzen willst -> *brrr*
Bitte nimm einfach std::list und std::string und lerne was Konstruktoren sind... Das ganze ist trivial in 5-10 Zeilen loesbar und als bonus hast du die ganzen memory leaks und fehler auch noch raus.

Hä, wie meinst du das? Sorry, ich komme gerade nicht mit...

Das was Dir hier alle sagen wollen ist: Versehe 'mplayerinfo' mit einem Konstruktor ...

class CPlayer {
    struct mplayerinfo 
    {
        mplayerinfo()
            : m_Name()
            , m_Address()
            , m_SteamID()
            , pEnt( 0 )
            , bIsConnected( false )
        {
            std::fill_n( iUnused, sizeof(iUnused)/sizeof(*iUnused), 0 ); // erfordert #include <algorithm>
            std::fill_n( fUnused, sizeof(fUnused)/sizeof(*fUnused), 0.0f );
        }
        mplayerinfo( edict_s* player, const std::string& name, const std::string& address, const std::string steamID )
            : m_Name( name )
            , m_Address( address )
            , m_SteamID( steamID )
            , pEnt( player )
            , bIsConnected( false )
        {
            std::fill_n( iUnused, sizeof(iUnused)/sizeof(*iUnused), 0 );
            std::fill_n( fUnused, sizeof(fUnused)/sizeof(*fUnused), 0.0f );
        }
        std::string m_Name; // erfordert #include <string>
        std::string m_Address;
        std::string m_SteamID;
        edict_s *pEnt;
        bool bIsConnected;
        int iUnused[4];
        float fUnused[4];
    };

    private:
        std::vector< mplayerinfo > m_player; // erfordert #include <vector>

    public:
        CPlayer() 
            : m_player()
        {}

und nutze das was der C++-Standard bietet, dann reduziert sich AddPlayer und RemovePlayer zu:

void CPlayer::AddPlayer(edict_s* player, const char *pszName, const char *pszAddress, const char *pszSteamID)
{
    m_player.push_back( mplayerinfo( player, pszName, pszAddress, pszSteamID ) );
}

void CPlayer::RemovePlayer( const unsigned int pid )
{
    assert( pid < m_player.size() ); // erfordert #include <cassert>
    m_player.erase( m_player.begin() + pid );
}

Du brauchst weder next noch die id noch einen Destruktor.

Gruß
Werner

Und ich MUSS eine verkettete Liste nehmen, ich darf keine Alternative wählen. Könnt ihr mir helfen?

Geht es nur um die zugrunde liegende Datenstruktur, die eine Liste sein muss? Oder musst du sie auch selber implementieren?

Im ersten Fall: Nimm - wie schon mehrmals erwähnt und von dir ebenso oft ignoriert wurde - std::list !

Kannst du mir bitte per Code zeigen, wie du es meinst? Sonst verstehe ich es nicht.

Ja, kann ich. Mach ich aber nicht.
Weil du selber auch ein bisschen was tun darfst.

Nimm ein Blatt Papier und einen Bleistift (die 2 wichtigsten Tools eines Programmieres) und zeichne dir auf was passiert wenn du 3 Elemente in der Liste hast und du das 2. Element löschen willst.

Worauf zeigen die 3 next-Zeiger vor dem löschen und worauf zeigen sie danach.