Problem mit free/malloc/realloc management !

Hi,

Das Problem ist eig. ganz EInfach nur weiß ich darauf keine gute Lösung, deswegen wollt ich einfach mal euch fragen, wer mir da helfen könnte...

Ich habe folgende Struktur: ( mit eig. String-Klasse )

typedef struct mysql_field_type
{
  String name;					/* Name of column */
  String table;					/* Table of column if column was a field */
  String def;					/* Default value (set by mysql_list_fields) */
  enum enum_field_types type;	/* Type of field. Se mysql_com.h for types */
  unsigned int length;			/* Width of column */
  unsigned int max_length;		/* Max width of selected set */
  unsigned int flags;			/* Div flags */
  unsigned int decimals;		/* Number of decimals in field */
}mysql_field_t;

Nun legt ich ein Array diesen Types an(free()). Bevor ich aber nun den Buffer deallokier muss ich zuerst name/table releasen, den sonst wird ja der speicher nicht mehr deallokiert, den sie beansprucht hat => Es wird ja kein destruktor aufgerufen...

Wenn ich das dann sehr häufig machen muss wird das sehr unüberblicklich wann ich die release funktion aufrufen muss. Und sobal einmal der Speicher nicht freigegben wird, hat das fatale Folgen, da das Programm ja viele Monate ununterbrochen laufen soll=>und stabiel !!!.

Naja mit new/delete wäre es eine alternative, jedoch wird das dann mit dem reallokieren Problematisch, da ich ja keine allgemeine Funktion dafür schreiben kann und dann immer eine new/new/delete operation kommt.

Habt ihr für sowas eine gute/akzeptable Lösung ?

Ciao

Shlo

malloc ruft keinen ctor auf und free keinen dtor. Wenn du kein new/delete nehmen willst, warum nicht std::vector, std::list je nach dem wie die Elemente eingefügt werden oder zugegriefen wird?

Hm,

und wie würde das in meinem Beispiel aussehen ?

otze

std::vector<Datensatz_Typ> vector
//einlesen
vector.push_back(Datensatz);
vector.push_back(Datensatz2);
vector.push_back(Datensatz3);
vector.push_back(Datensatz4);
//usw
//auslesen
vector[0](=Datensatz)
vector[1](=Datensatz1)
vector[2](=Datensatz2)
//usw

vector ist einer der stl containr.
Er kümmert sich für dich um das komplette speichermanagement der Objekte die er verwaltet

std::list<Datensatz_Typ> list;
//einlesen
list.push_back(Datensatz1)
//usw
//auslesen
for(std::list<Datensatz_Typ>::iterator iterator=list.begin();i<list.end();++i){
      iterator;//datensatz 1-letzter.
}

list ist ein weiterer container. sie speichert die Dateien in einer doppelt verketteten liste, kann bei programmen mit enorm vielen Datensätzen effektiver als vector sein.

Ok thx!

Was bedeutet denn "iterator" ?

Bye

otze

schau in die hilfe deines compilers.

Hilfe schrieb:

Pointer generalizations for traversal and modification of collections.

Description

Iterators are a generalization of pointers that allow a C++ program to uniformly interact with different data structures. The illustration below displays the five iterator categories defined by the standard library, and shows their hierarchical relationship. Because standard library iterator categories are hierarchical, each category includes all the requirements of the categories above it.

Because iterators are used to traverse and access containers, the nature of the container determines the type of iterator it generates. Also, because algorithms require specific iterator types as arguments, it is iterators that, for the most part, determine which standard library algorithms can be used with which standard library containers.

To conform to the C++ standard, all container and sequence classes must include their own iterator types. Each iterator may be a class defined within the container or may be a simple pointer, whichever is appropriate.

Containers and sequences must also include const iterators that point to the beginning and end of their collections. These may be accessed using the class members, begin() and end().

Because the semantics of iterators are a generalization of the semantics of C++ pointers, every template function that takes iterators also works using C++ pointers to contiguous memory sequences.