Kategorie: Arrays

• neben std::vector gibt es unter MS Visual Studio noch ein Objekt, was zur Verwaltung von Objektlisten dient: die Template Klasse CList
• folgender Code erweitert die CList um nützliche Funktionen:

#pragma once
//---------------------------------------------------------------------------
#ifndef CListeH
#define CListeH
//---------------------------------------------------------------------------
template <class T> class CListe : public CList<T, T>
{
  public:
    
    // destruktor, damit auch alle Objekte beim Zerstören der Liste
    // mit aus dem Speicher entfernt werden
    virtual ~CListe()
    {
        delete_all();
    };

    // fügt Objekt vom Typ T der Liste hinzu
    void Add(T I)
    {
        AddTail(I);
    };

    // gibt Objekt bei iIndex zurück
    T Item(int iIndex)
    {
        T R = NULL;

        if ((iIndex < GetCount()) && (iIndex >= 0))
        {
           R = ((T)GetAt(FindIndex(iIndex)));
        }

        return R;
    };

    // gibt ein Objekt anhand seiner ID zurück (insofern es eine Eigenschaft iId hat)
    T Item_from_Id(int iId)
    {
        T R = NULL;
  
        for (int i=0; i<GetCount(); i++)
        {
            T RTemp = ((T)GetAt(FindIndex(i)));
    
            if (RTemp)
            {
                if (RTemp->iId == iId)
                {
                    R = RTemp;
                    break;
                }
            }
        }
  
        return R;
    };

    // löscht ein Item anhand seines Indexes aus der Liste und aus dem Speicher
    void _delete(unsigned int uiIndex)
    {
         T R=((T)GetAt(FindIndex(uiIndex)));

         RemoveAt(FindIndex(uiIndex));

         if (R)
         {
            delete R;
            R = NULL;
         }
    };

    // löscht ein Item anhand der Id aus der Liste und aus dem Speicher
    // (auch mehrere mit der selben Id)
    // gibt die Anzahl der gefundenen (gelöschten) Items zurück
    int _delete_by_id(int iId)
    {
        int iAnzDelObj = 0;

        for (int i=0; i<GetCount(); i++)
        {
            T R=((T)GetAt(FindIndex(i)));

            if (R)
            {
              if (R->iId == iId)
              {
                _delete(i);
                i--;
                iAnzDelObj++;
              }
            }
        }

        return iAnzDelObj;
   };

    // löscht alle Objekte in der Liste und im Speicher
    void delete_all()
    {
        while (GetCount() > 0)
        {
            _delete(0);
        }
    };

    //  GetNewBlockId() gibt eine gültige freie Block-ID aus der Liste zurück
    int GetNewBlockId()
    {
        bool bFound = true;
        int  iIdCount = 0;

        while (bFound)
        {
            iIdCount++;
            bFound = false;
          
            for (int i=0; i<GetCount(); i++)
            {
                if (Item(i)->iId == iIdCount)
                {
                    bFound = true;
                    break;
                }
                else
                {
                    bFound = false;
                }
            }
        }

        return iIdCount;
    };
};
//---------------------------------------------------------------------------
#endif

• verwendet wird das Ganze wie folgt:

// Beispielobjekt zur Verwaltung durch CListe deklarieren
class TXYValue
{
public:
  double x;
  double y;
  int iId;

  TXYValue(double dx, double dy);
  {
       x = dy;
       y = dy;
  }

  ~TXYValue(void);
};

// Liste erzeugen
CListe<TXYValue*> *pCList = new CListe<TXYValue*>;

// Element zu Blockliste hinzufügen
TXYValue *pXY = new TXYValue();
pXY->iId = pCList->GetNewBlockId();
pCList->Add(pXY);

// Element anhand seines Indexes ermitteln
int iIndex = 2;
TXYValue *pXY = pBlockList->Item(iIndex);

// Element anhand seiner ID ermitteln
int iID = 2;
TXYValue *pXY = pBlockList->Item_from_Id(iID);

// Element anhand seines Indexes löschen
int iIndex = 0;
pCList->_delete(iIndex);

// Element anhand seiner ID löschen
int iID = 1;
int iDelElements = pCList->_delete_by_id(iID);

// nur Elemente der Liste löschen
pCList->delete_all();

// Liste und alle Elemente der Liste zerstören
delete pCList;

• Allgemeine Funktionen

// Objekt zur Verwaltung durch den Vektor deklarieren
class TXYValue
{
public:
  double x;
  double y;

  TXYValue(double dx, double dy);
  {
       x = dy;
       y = dy;
  }

  ~TXYValue(void);
};

// Liste, die Zeiger auf Objekte vom Typ TXYValue verwaltet, deklarieren
// #include <vector> für std::vector nicht vergessen!
std::vector<TXYValue*> InputValues;

// 3 Objekte hinzufügen
InputValues.push_back(new TXYValue(0.1, 0.2));
InputValues.push_back(new TXYValue(0.4, 0.2));
InputValues.push_back(new TXYValue(0.6, 0.8));

// erstes Objekt anhand des Indexes holen
TXYValue *pXY = InputValues[0];

// alle Objekte im Vektor löschen
// dabei Liste durchgehen und alle Objekte im Speicher zerstören (delete)
for (int i = 0; i < InputValues.size(); i++)
{
    TXYValue *pXY = InputValues[i];
    if (pXY) delete pXY;
}
InputValues.clear(); // zuletzt noch alle Zeiger in der Liste löschen

// erstes Element im Vektor löschen
TXYValue *pXY = InputValues[i];
if (pXY) delete pXY;
InputValues.erase(InputValues.begin());

• Vektor sortieren

// als erstes ein Struct definieren, in dem ein
// Vergleichsoperator für die Sortierung implementiert wird
struct SDESCSort
{
    // Liste absteigend anhand des y-Wertes sortieren
    bool operator()(TXYValue *V1, TXYValue *V2)
    {
        return (V1->y > V2->y);
    };
};

// Aufruf der Sortierung
// #include <algorithm> für std::sort nicht vergessen!
std::sort(InputValues.begin(), InputValues.end(), SDESCSort());