Ich habe mir eine kleine linked_list Klasse gecodet, welche auf class templates basiert (da Generics ja scheinbar erst bei MS VS C++ 2005 integriert sind, ich aber nur die 2003 version habe). Im Gegensatz zu der STL version soll meine linked_list nur die Funktionen aufweisen, die ich brauche, und dadurch für mich leichter zu verwenden sein. Deswegen habe ich überhaupt eine eigene machen wollen.

Jetzt habe ich aber ein grosses Problem, und zwar geht es um Memory leaks, bzw um Memory Management, Garbage Collector usw...

Ich habe es so gemacht, dass beim Entfernen eines Elements aus der Liste, das Element ebenfalls aus dem Speicher mittels free(ptr_to_element) entfernt wird.

Jetzt habe ich folgende Probleme / Fragen:

[]Was wenn ein anderer Pointer ausserhalb der Liste noch darauf gezeigt hat??
[]Was wenn das Item des Elements ein Struct, oder Klasse ist, die wiederum Pointer auf alloziierte Speicher besitzt??
[]Wie kann ich im Element Destruktor unterscheiden, ob ein Primitive Type oder ein referenzierter item Typ vorliegt?? und dann davon abhängig evtl. free() benutzen?
[]Wie kann ich free() nur dann benutzen, wenn kein anderer Pointer mehr darauf zeigt??
[*]Ich habe mal was von "auto_pointer" gehört, würde mir das hier nützen und wenn ja, wie?

Ja das sind viele Probleme, und genauso komme ich mir im Moment auch vor; wie soll ich das nur lösen??
Ich bin für jede Anregung, Tips, oder gar Lösungsvorschläge sehr dankbar!

Falls gewünscht kann ich auch meinen Linked_list C++ Code pasten.

grüsse,
Barnski.

Generics sind C#, nicht C++. Es wird nicht gern gesehen, wenn man Sprachen durcheinander würfelt.
Desweiteren benutzt man in C++ weder malloc noch free sondern new und delete.

Zu deinen Fragen:

1. Dann hat er Pech gehabt.
2. Dann hat es Pech gehabt. (Es sei denn, es hat einen Destruktor und du benutzt new/delete)
3. Gar nicht, du benutzt kein free.
4. Gar nicht, du benutzt kein free. (Was du meinst ist ein SharedPointer, der macht das automagisch)
5. s.o. (Aber für diesen Fall keinen auto_ptr, der übergibt die Zuständigkeit)

.filmor schrieb:

Autsch!

Generics sind C#, nicht C++. Es wird nicht gern gesehen, wenn man Sprachen durcheinander würfelt.

Das Generics in C++ 2005 zur Verfügung steht habe ich von MSDN:
http://msdn2.microsoft.com/en-us/library/8z2kbc1y(en-US,VS.80).aspx

Auszug aus MSDN: schrieb:

C++ Language Reference
Generics (C++)

Visual C++ 2005 introduces support for generic methods and types in C++. In this section, find out how to author your own generic methods and types in C++ and how to use generic types authored in C# or another language in C++. This section also includes a comparison of generics and C++ templates.

Aber da ich leider Visual C++ 2003 habe, muss ich mich mit templates zufrieden geben.

.filmor schrieb:

Desweiteren benutzt man in C++ weder malloc noch free sondern new und delete.

Danke für den Hinweis, habe meinen Code jetzt darauf umgestellt. Allerdings rufen new und delete jeweils auch malloc und free auf wie ich gesehen habe. New scheint mir übrigens ein nicht ganz vollwertiger Ersatz für malloc zu sein, da man da keine eigene Speichergrösse angeben kann.

Also meine linked_list und linked_cell haben/sollen beide Konstruktoren, Copy-Knstr, assignment-oper, und destruktor (haben).
Dennoch scheint das Ganze noch nicht zu klappen.

Meine Probleme:

• Aufgrund der templates kann das item in der linked_cell mal eine Klasse, mal ein struct, und mal ein primitive type (int, double usw..) sein. Deshalb motzt der Compiler wenn ich im destruktor der linked_cell ein "delete item" mache, falls das item ein primitive type ist. Kann ich das nicht irgendwie unterscheiden je nach template type??
• Der Compiler reklamiert wenn ich einen assignment-operator implementiere. Was ist daran falsch ??

template<class G> class linked_cell {
public:
//[...]
// assignment-operator
	linked_cell &operator=(const linked_cell<G>&);
};
//[...]
template<class G> &linked_cell<G>::operator=(const linked_cell<G> &other) {
		// assignment-operator (object-copy).
	previous = other.previous;
	next = other.next;
	item = other.item;
	key = other.key;
}
//[...]

• Irgendwie scheint er Objekt-Referenzen (pointer) nicht richtig zuzuweisen. Folgendes sollte doch funktionieren, jedoch wird "first" nicht auf das nächste element gesetzt, wenn das erste gelöscht wird. Weshalb nicht, der Code müsste doch stimmen??

//[...]
template<class G> void linked_list<G>::remove_el(linked_cell<G> *a_cell) {
		// remove element. do not change cursor (or change to next).
		// requires a_cell to be element of list and not NULL.
		// requires caller to free allocated space for the element afterwards.
	if (a_cell->previous == NULL) {
				// cell is at beginning
		first = a_cell->next;
		if (first != NULL) {
			first->previous = NULL;
		} else {
			last = NULL;
			after = true;
		}
		if (a_cell == current) {
			current = first;
		}
	} else if (a_cell->next == NULL) {
				// cell is at end
		last = a_cell->previous;
		last->next = NULL;
		if (a_cell == current) {
			current = NULL;
			after = true;
		}
	} else {
				// cell inbetween
		a_cell->previous->next = a_cell->next;
		a_cell->next->previous = a_cell->previous;
		if (a_cell == current) {
			current = current->next;
		}
	}
	count--;
};
//[...]

Die Probleme scheinen irgendwie nicht zu schwinden... ist mein Vorhaben überhaupt realisierbar??

Ich hoffe ich habe das Ganze verständlich rüber gebracht.

grüsse,
Barnski.

Das Generics in C++ 2005 zur Verfügung steht habe ich von MSDN

1. Du meinst Visual C++ 2005 (Das aktuelle C++ ist C++98)
2. Die Generics sind iirc eine Eigenschaft des CLR, also der .NET-Umgebung. Man verwendet also kein C++ sondern Managed-C++ oder C++/CLI. Übrigens lassen die sich auch in ISO-C++ realisieren (void-Zeiger in einem privaten Unterbau und Templateklasse als Wrapper).

Barnski schrieb:

Allerdings rufen new und delete jeweils auch malloc und free auf wie ich gesehen habe.

Das ist irrelevant, sie sorgen (auch wenn das im Code möglicherweise nicht sichtbar ist) für Konstruktor und Destruktor Aufrufe, beides Sachen, die malloc/free nicht tun.

Barnski schrieb:

New scheint mir übrigens ein nicht ganz vollwertiger Ersatz für malloc zu sein, da man da keine eigene Speichergrösse angeben kann.

Wozu sollte man das wollen? Arrays alloziiert man per new[] und ansonsten bekommt new die Größe automatisch über den zu alloziierenden Typ. Du kannst natürlich auch den ::operator new manuell aufrufen und ihm eine Größe übergeben (ist aber in den meisten Fällen ziemlich sinnlos). Für Arrays benutzt man in C++ new[] und delete[].

Barnski schrieb:

[*]Aufgrund der templates kann das item in der linked_cell mal eine Klasse, mal ein struct, und mal ein primitive type (int, double usw..) sein. Deshalb motzt der Compiler wenn ich im destruktor der linked_cell ein "delete item" mache, falls das item ein primitive type ist. Kann ich das nicht irgendwie unterscheiden je nach template type??

Könntest du da genauere Informationen rausrücken? Wenn du den Speicher mit new alloziiert hast, lässt er sich auch mit delete freigeben, egal ob POD (C-Struct bzw. int etc.) oder Klassenobjekt.

Barnski schrieb:

[*]Der Compiler reklamiert wenn ich einen assignment-operator implementiere. Was ist daran falsch ??

Formal nichts, bitte Fehlermeldung.

Barnski schrieb:

[*]Irgendwie scheint er Objekt-Referenzen (pointer) nicht richtig zuzuweisen. Folgendes sollte doch funktionieren, jedoch wird "first" nicht auf das nächste element gesetzt, wenn das erste gelöscht wird. Weshalb nicht, der Code müsste doch stimmen??

Referenzen != Zeiger! Was ist first?

Barnski schrieb:

Die Probleme scheinen irgendwie nicht zu schwinden... ist mein Vorhaben überhaupt realisierbar??

Natürlich ist es das, es ist ja auch schon annähernd $2^100$-mal implementiert worden (z.B. auch in der C++-Standardbibliothek, siehe Header <list>.

Ja, ich benutze MS Visual Studio 2003. Meine anfängliche Bemerkung wegen Generics bezog sich auf VC++ 2005, Microsoft hat das da offenbar mitintegriert, wie du erklärt hast.

.filmor schrieb:

Könntest du da genauere Informationen rausrücken? Wenn du den Speicher mit new alloziiert hast, lässt er sich auch mit delete freigeben, egal ob POD (C-Struct bzw. int etc.) oder Klassenobjekt.

Wenn ich folgendes mache, gibt der Compiler nachfolgende Fehlermeldung aus:

//destructor
template<class G> linked_cell<G>::~linked_cell() {
		// destructor of linked_cell. free allocated memory by current cell.
	delete item;  // zeile 66
}

//[...]
linked_list<int> a_test;
//[...]

vc++ compiler schrieb:

linked_cell.h(66): error C2541: 'delete' : cannot delete objects that are not pointers

Wie kann ich in diesem Zusammenhang new verwenden bei int und wo?

Die linked_cell Klassendefinition sieht folgendermassen aus:

template<class G> class linked_cell {

public:
// constructor
	linked_cell(const G);
	linked_cell(const G, int);
// copy constructor
	linked_cell (const linked_cell<G>&);
// assignment-operator
	//linked_cell &operator=(const linked_cell<G>&);
// destructor
	~linked_cell();

// attributes
	// reference to previous cell.
	linked_cell<G> *previous;

	// reference to next cell.
	linked_cell<G> *next;

	// reference to item of this cell (may be primitive type).
	G item;

	// key for searching & sorting.
	int key;

// queries
};

assignment operator auskommentiert weil er ne fehlermeldung gibt, und zwar folgende:

vc++ compiler schrieb:

linked_cell.h(61): error C2501: 'linked_cell<G>::=' : missing storage-class or type specifiers

Zeile 61 ist einfach nach der Implementierung der Methode:

template<class G> &linked_cell<G>::operator=(const linked_cell<G> &other) {
		// assignment-operator (object-copy).
	previous = other.previous;
	next = other.next;
	item = other.item;
	key = other.key;
} // zeile 61

.filmor schrieb:

Referenzen != Zeiger! Was ist first?

Referenzen verhalten sich aber bei der Syntax gleich wie Pointer oder?
also

my_class *my_object;

gibt eine Referenz auf ein Objekt,
wenn ich die Referenz umlenken will, mache ich

my_object = new my_class(); //mit konstruktor

Oder liegt da etwa der Hund begraben??

Hiermit komme ich auch gerade zu "first". So sieht die linked_list Klassen definition aus:

template<class G> class linked_list {

public:

//Constructor
	linked_list();
//copy-constructor
	linked_list (const linked_list<G>&);
//destructor
	~linked_list();
//attributes
	// reference to first cell, NULL if list is empty.
	linked_cell<G> *first;

	// reference to current cell, NULL if not set. start() sets it to first.	
	linked_cell<G> *current;

	// reference to last cell, NULL if list is empty.	
	linked_cell<G> *last;

	// current index of cursor.	
	int index;

	// num of elements in the list.
	int count;

	// is cursor after the end of the list?
	bool after;

	// sort mode of the list: 0=not_sorted, -1=downwards, 1=upwards
	//enum sortmode {downwards=-1, not_sorted=0, upwards=1} sort_mode;
	int sort_mode;

//queries
	// return i_th cell.	
	linked_cell<G> *i_th(int);

//commands
//[...]
	// remove current element.
	void remove();

	// remove an element.
	void remove_el(linked_cell<G>*);

	// remove i_th element.
	void remove_i_th(int);
//[...]
};

Hier die relevanten implementierten Methoden:

template<class G> void linked_list<G>::remove_el(linked_cell<G> *a_cell) {
		// remove element. do not change cursor (or change to next).
		// requires a_cell to be element of list and not NULL.
		// requires caller to free allocated space for the element afterwards.
	if (a_cell->previous == NULL) {
				// cell is at beginning
		first = a_cell->next;
		if (first != NULL) {
			first->previous = NULL;
		} else {
			last = NULL;
			after = true;
		}
		if (a_cell == current) {
			current = first;
		}
	} else if (a_cell->next == NULL) {
				// cell is at end
		last = a_cell->previous;
		last->next = NULL;
		if (a_cell == current) {
			current = NULL;
			after = true;
		}
	} else {
				// cell inbetween
		a_cell->previous->next = a_cell->next;
		a_cell->next->previous = a_cell->previous;
		if (a_cell == current) {
			current = current->next;
		}
	}
	count--;
};

template<class G> void linked_list<G>::forth() {
		// set current to next cell. index will increase. if end of list is reached, after is set to true.

	if (current == NULL) {
			// current cell is after end of list or not yet initialized.
		after = true;
		index = 0;
	} else {
			// current cell is valid.
		current = current->next;
		index++;
		after = (current == NULL);
	}
};

template<class G> void linked_list<G>::start() {
		// set current to first and index = 0 and after = false if list not empty.
	current = first;
	index = 0;
	after = (first == NULL);
};

Danke für die Mühe & Antworten,

gruss,
Barnski.

.filmor schrieb:

Könntest du da genauere Informationen rausrücken? Wenn du den Speicher mit new alloziiert hast, lässt er sich auch mit delete freigeben, egal ob POD (C-Struct bzw. int etc.) oder Klassenobjekt.

Wenn ich folgendes mache, gibt der Compiler nachfolgende Fehlermeldung aus:

//destructor
template<class G> linked_cell<G>::~linked_cell() {
		// destructor of linked_cell. free allocated memory by current cell.
	delete item;  // zeile 66
}

//[...]
linked_list<int> a_test;
//[...]

vc++ compiler schrieb:

linked_cell.h(66): error C2541: 'delete' : cannot delete objects that are not pointers

Wie kann ich in diesem Zusammenhang new verwenden bei int und wo?

Du bekommst den Item-Inhalt von der Anwendung, richtig? Also kannst du auch die Anwendung dafür verantwortlich machen, einen vernünftigen Destruktor dafür bereitzustellen (int braucht nicht aufgeräumt zu werden - und selbt bei einer linked_list<int*> kannst du nicht wissen, ob dort ein delete nötig ist, also überlass das besser demjenigen, der die Liste verwenden will).

assignment operator auskommentiert weil er ne fehlermeldung gibt, und zwar folgende:

vc++ compiler schrieb:

linked_cell.h(61): error C2501: 'linked_cell<G>::=' : missing storage-class or type specifiers

Zeile 61 ist einfach nach der Implementierung der Methode:

template<class G> &linked_cell<G>::operator=(const linked_cell<G> &other) {
		// assignment-operator (object-copy).
	previous = other.previous;
	next = other.next;
	item = other.item;
	key = other.key;
} // zeile 61

Du hast bei der Definition den Rückgabetyp vergessen: "template<class G> linked_cell<G>& linked_cell<G>::operator=(const linked_cell<G>& other)..."

.filmor schrieb:

Referenzen != Zeiger! Was ist first?

Referenzen verhalten sich aber bei der Syntax gleich wie Pointer oder?
also

my_class *my_object;

gibt eine Referenz auf ein Objekt,
wenn ich die Referenz umlenken will, mache ich

my_object = new my_class(); //mit konstruktor

Oder liegt da etwa der Hund begraben??

Nein, was du da verwendest, sind Pointer - Referenzen deklarierst du mit "my_class& my_object = some_other_object;" und kannst sie im Nachhinein nicht mehr umbiegen.
(und für eine Linked-List sind Referenzen auch nicht wirklich brauchbar, weil du die Listenelemente ja umhängen mußt)

Wollte mich nur noch für die Hilfe bedanken @ CStoll und .filmor.

Meine linked list scheint jetzt zu funktionieren, und den Speicher werde ich nun nicht mehr von der liste selber löschen lassen, sondern mir was anderes überlegen..

gruss,
Barnski.

und den Speicher werde ich nun nicht mehr von der liste selber löschen lassen, sondern mir was anderes überlegen..

Du kannst dafür Policies verwenden:

template <typename T>
struct PolDelete
{
   void deleteIt(T t)
   {
      // wenn kein Zeiger, dann mache nichts
   }
};

/// Spezialisierung für Zeiger
template <>
struct PolDelete<T*>
{
   void deleteIt(T t)
   {
      delete t;
   }
};

/// und verwenden kanns Du das dann so:
template<class G> linked_cell<G>::~linked_cell() {
        // destructor of linked_cell. free allocated memory by current cell.
    PolDelete<G> pd;
    pd.deleteIt(item);  // zeile 66
}

So sollte es funktionieren, vielleicht macht da der VC++ Probleme.

Ich habe mich jedoch dazu entschlossen einen eigenen Garbage Collector zu schreiben, mit eigenen malloc und free funktionen.

der soll einen memory automatisch freigeben wenn kein Pointer mehr darauf zeigt!

gruss,
Barnski

übrigens für alle die's interessiert, ich habe hier ein GC-FAQ gefunden:

http://www.iecc.com/gclist/GC-faq.html

und ein smart-pointer FAQ:

http://ootips.org/yonat/4dev/smart-pointers.html

gruss,
Barnski.