Persistence

prøv at kigge lidt på TCollection

Jens B

Her du noget lidt mere specifikt, TCollection er ikke nævnt i microsofts visual developer library.

Her du et link?

Det er en C++ builder specifik komponent ...

TCollection is a container for TCollectionItem objects.

Unit

classes

Description

Each TCollection holds a group of TCollectionItem objects. TCollection maintains an index of the collection items in its Items array. The Count property contains the number of items in the collection. Use the Add and Clear methods to add items to the collection and delete items from the collection.

Du kan lave din egen med hægtede lister ...
Lav en klasse du kalder kø. Og så en anden klasse du kalder kø_node.
I din kø har du en pointer til hovedet af køen.
Kø_node *hoved;
Så skal du lave metoder i kø klassen til at Add´e et kø_node element
slette det igen
indsætte et element
indsætte forrest
indsætte bagerst
o.s.v

2 sec ....

Her en noget rodet udskrift af virkende kode der implmenterer en hægtet liste, jeg har brugt den i sin tid til at parse querystring med fra et C prog på en unix mask.
Der er klasserne: parser, pairlist, pair
Hvor parseren gør brug af tpairlist der holder styr på pairs ...
jeg har taget alle klassedefinitioner med men kun funktionerne til pairlist og pair samt konstruktøren til parser.



class TPair
{
private:

public:
char Name[MAXARRAY];
char Value[MAXARRAY];

TPair* Next;

TPair(char*, char*);
};

//TPair methods

TPair::TPair(char* aName, char* aValue)
{
    strcpy(Name, aName);
  strcpy(Value, aValue);

    Next = NULL;
}


class TPairList
{
private:

public:

TPair* First;

TPairList();
void NewPair(char*, char*);      //startes fra TParser og modtager
char* GetValue(char*);            //Name og Value fra TParser, til
                                  //initaialisering af nyt TPair.
};

//TPairlist methods

TPairList::TPairList()
{
First = NULL;                    //kommer til at pege på par 1.
}

char* TPairList::GetValue(char* aName)
{
int Flag = 1;                  //sat til sandt
TPair* hjelpepeger = First;

while(Flag)
{
  if(First == NULL)
  {
  return NULL;
  }

  else
  {
    if(strcmp(First -> Name, aName) == 0)
    {
    return First -> Value;
    }

      else
      {
          if(hjelpepeger -> Next != NULL)
          {
              if(strcmp(hjelpepeger -> Next -> Name, aName) == 0)
              {return hjelpepeger -> Next -> Value;}

                else
                {
                hjelpepeger = hjelpepeger -> Next; //ryk en frem
                }

        }

                else
                {
                char* error=\"Navnet kunne ikke findes ... \";
                cout<<\"\\nSøgt navneværdi: \"<<aName<<endl;
                return error;
                }

      }

  }//slut yderste else
}    //slut while - løkke
}


void TPairList::NewPair(char* aName, char* aValue)
{
int True  = 1;
int False = 0;
if(First == NULL)
First = new TPair(aName, aValue);
else
{
    TPair* hjelpepeger = First;
    while(True)
  {
    if(hjelpepeger -> Next == NULL)
      {
      hjelpepeger -> Next = new TPair(aName, aValue);
        True = False;                                  //stop løkke
      }
        else
      hjelpepeger = hjelpepeger -> Next;            //ryk én frem
  }
}
}


class TParser
{
private:

char* Query;                  //Peger på starten af QUERYSTRING
char* Method;
int  Length;                  //længden af Query
char* Source;                  //Source rykker frem gennem Query
char* Name;                    //Name og Value sendes til Liste
char* Value;

public:
TPairList* PairList;

TParser();                    //Konstruktøren indlæser \"QUERY_STRING\"
char* GetValue(char*);        //sender forespørgsel til Pairlist
void InsertSpaces();
TPairList* Parse();        //Parser og returnerer liste
};

//TParser methods

TParser::TParser()
{
PairList = new TPairList();

Query  = getenv(\"QUERY_STRING\");
Method = getenv(\"REQUEST_METHOD\");

Length  = strlen(Query);              //bruges i for - løkke
Name    = NULL;
Value  = NULL;
}


Venlig hilsen Thue

Hvad er alt dette for noget? Det kunne vist lige implementeres mere portabelt og kort. For det første kan du starte med at fordre at alle dine klasser implementerer

ostream &operator<<(ostream &s,const T &x);

hvor det er den enkelte klasse, du skal kunne implementere på din liste, vektor eller hvad pokker du vil.

Derefter anvender du en implementering af STL - Plaugers implementering i Microsoft VC er fin nok:

#include <list>
using namespace std;

template<typename T> ostream &operator<<(ostream &s,const list<T> &l) {
  for (list<T>::const_iterator i = l.begin();i != l. end();++i) s << *i << \" \";
  return s;
};

altså reelt en linje kode. Til container strukturer som lister, vektorer, associative arrays og mænger, anvend STL. Og så lad være med at spilde tid på en masse åndsvag genimplementering af kendt kode. Og det er såmænd ikke det store problem at parametrisere yderligere med seperatorer såsom \" \", \",\" og \";\", det kan du blot give som yderligere give som template-parametre. Og måske lidt mere genbrugeligt end ovenstående. ostream_itereator og istream_iterator kan du så senere lege med.

Tak for svarene, men:

Mit problem er stadigt at gemme listen på disk, og være i stand til at hente/genopbygge listen igen...

Jamen... Lad os nu sige at du vil gemme dem:

list<int> l;
// Kode, der fylder l ud...

// og så gemmer vi:
ofstream f(\"MyFavoriteFileName.bob\");
f << l;

// en anden gang henter vi fra disken.
f >> l;

cool.
Jeg er ikke særlig meget inde i hvad der rent faktisk ligger af templates man kan trække på.
Derfor byggede jeg i sin tid en egen hægtet liste, som jeg dengang følte mig mere tryg ved.
:)
Thue