spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

C-/C++-Quelltext

class VerbManager
{
       public:
       unsigned long AddVerb (Verb *pVerb) {m_List.push_back(pVerb);}
       Destroy () {for (m_iterator=m_List.begin(); m_iterator != m_List.end(); ++i){delete (*m_iterator);}}

       Load () { // Aus Datei laden}

       Save() {// In Datei Speichern}


       ...
public:
      std::list<Verb*> m_List;
      std::list<Verb*>::iterator m_iterator;
}

int WINAPI WinMain (....)
{
     Verb *V = new Verb;
     VerbManager VM;
     VerbManager VM2;
     std::wstring S[25];

     for (unsigned int i=0; i < 25; ++i)
     {
    S[i] = L"Hi";
     }

     V->SetConjugations(S);

     VM.AddVerb (V);

     VM.Save ();

      if (VM2.Load ())
          return 1;

      MessageBox (NULL, VM2.GetVerb()->GetConjugation(1).c_str(), L"", MB_OK);

         VM.Destroy ();    // <------- Fehler nummer 1: hier kann der iterator nicht erhöht werden

    VM2.Destroy ();  // <--------- Fehler nummer 2: hier heißts BLOCK_TYPE_IS_VALID

}

C-/C++-Quelltext

/*******   I N C L U D E S   ************************************************/
#include "VerbManager.h"
#include "Verb.h"
#include <windows.h>

int WINAPI WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance,
                    LPSTR lpCmdLine, int nShowCmd)
{
    Verb *V = new Verb;
    VerbManager VM;
    VerbManager VM2;
    std::wstring S[25];

    for (unsigned int i=0; i < 25; ++i)
    {
        S[i] = L"Hi";
    }

    V->SetConjugations(S);

    VM.AddRightVerb (V);

    VM.Save ();

    if (VM2.Load ())
        return 1;

    MessageBox (NULL, VM2.GetRightVerb()->GetConjugation(1).c_str(), L"", MB_OK);

                VM.Destroy ();
    VM2.Destroy ();

    return 0;
}

C-/C++-Quelltext

class Verb
{
public:

    // Setzt den Konjugationsstring

    unsigned long SetConjugations (std::wstring Conjugations[25]);

    // Liefert einen String aus dem Konjugatiuonsarray

    std::wstring GetConjugation (unsigned int Index){return m_Conjugations[Index];}

private:
    std::wstring m_Conjugations[25];
};

unsigned long Verb::SetConjugations(std::wstring Conjugations[25])
{
    for (unsigned int i=0; i < 25; ++i)
    {
        m_Conjugations[i] = Conjugations[i];
    }

    return 0x00000000;
}

C-/C++-Quelltext

class Verb;

/*******   S T R U K T U R E N   ********************************************/
class VerbManager
{
public:

    unsigned long Load ();
    unsigned long Save ();

    Verb *GetRightVerb ();
    Verb *GetWrongVerb ();
    Verb *GetUndoneVerb ();

    unsigned long AddWrongVerb (Verb *WrongVerb);
    unsigned long AddRightVerb (Verb *RightVerb);

    unsigned long DeleteWrongVerb ();
    unsigned long DeleteRightVerb ();
    unsigned long DeleteUndoneVerb ();

    unsigned long Destroy ();

private:
    std::list<Verb*> m_WrongVerbs;
    std::list<Verb*>::iterator m_wi;
    std::list<Verb*> m_RightVerbs;
    std::list<Verb*>::iterator m_ri;
    std::list<Verb*> m_UndoneVerbs;
    std::list<Verb*>::iterator m_ui;

};

Verb *VerbManager::GetRightVerb()
{
    return m_RightVerbs.front();
}

Verb *VerbManager::GetUndoneVerb() 
{
    return m_UndoneVerbs.front();
}

Verb *VerbManager::GetWrongVerb()
{
    return m_WrongVerbs.front();
}

// Löscht das erste Verb aus der Liste

unsigned long VerbManager::DeleteRightVerb()
{
    m_RightVerbs.pop_front ();

    return 0x00000000;
}

unsigned long VerbManager::DeleteUndoneVerb()
{
    m_UndoneVerbs.pop_front ();

    return 0x00000000;
}

unsigned long VerbManager::DeleteWrongVerb()
{
    m_WrongVerbs.pop_front ();

    return 0x00000000;
}

// Fügt ein Verb hinten an

unsigned long VerbManager::AddRightVerb(Verb *RightVerb)
{
    m_RightVerbs.push_back (RightVerb);

    return 0x00000000;
}

unsigned long VerbManager::AddWrongVerb(Verb *WrongVerb) 
{
    m_WrongVerbs.push_back (WrongVerb);

    return 0x00000000;
}

// Speichert die Verben in eine Datei

unsigned long VerbManager::Save ()
{
    file::file File;

    // Datei öffnen

    if (File.open(L"Verbs.vcm", file::encoding::ANSI, true))
        return 0x00000001;

    unsigned int NumVerbs = static_cast<int>(m_RightVerbs.size());

    // In die Datei schreiben

    if (File.write((void*)(&NumVerbs), sizeof(unsigned int)))
        return 0x00000001;

    for (m_ri=m_RightVerbs.begin(); m_ri != m_RightVerbs.end(); ++m_ri)
    {
        if (File.write((*m_ri), sizeof(Verb)))
            return 0x00000001;
    }

    File.close ();

    return 0x00000000;
}

// lädt die Verben aus einer Datei

unsigned long VerbManager::Load()
{
    file::file File;

    // Verb konstruieren

    Verb *V;

    // Datei öffnen

    if (File.open(L"Verbs.vcm", file::encoding::ANSI))
        return 0x00000001;

    unsigned int NumVerbs = 0;

    unsigned long ReceivedBytes = 0;

    // Gröse der Liste auslesen

    if (File.read((void*)(&NumVerbs), sizeof(unsigned int)))
        return 0x00000001;

    V = new Verb[NumVerbs];

    for (unsigned int i=0; i < NumVerbs; ++i)
    {
        if(File.read((void*)(&V[i]), sizeof(Verb)))
            return 1;

        m_RightVerbs.push_back(&V[i]);
    }

    return 0x00000000;
}

// Zerstört die Listen

unsigned long VerbManager::Destroy()
{
    // Jedes Element durchgehen

    for (m_ri=m_RightVerbs.begin(); m_ri != m_RightVerbs.end(); ++m_ri)
    {
        delete (*m_ri);
    }
    m_RightVerbs.empty ();

    return 0;
}