3. Probleme mit Dereferenzieren

Probleme mit Dereferenzieren

  • A

    Hi,

    Ich bin der neue hier. Wie man meiner Signatur entnehmen kann Studier ich Elektro- und Informationstechnik an der Hochschule Darmstadt und befinde mich zZt. im ersten Semester. Dort sollen wir die handhabung einer höheren Programmiersprache erlernen und da unser Prof meint wird würdn Informatiker werden hat dieser einen Crashkurs in C++ mit uns durchgezogen.

    Nun habe ich nach guten 6std Programmieraufwand es endlich geschafft das mein MergeSort Algorithmus läuft. Jetz wollte ich nur nicht jedes mal die Array größe von Hand eintragen und bin darauf gekommen das ganze mit Zeigern zu Realisieren. Allerdings lässt sich die so erstellte Tabelle nicht mehr Löschen und ich weis nich wieso ... ist vielleicht etwas bei der Dereferenzierung schief gegangen? Das Thema wurde bei uns leider nich so großzügig behandelt...

    void merge(int a[], int l,int m,int r){
	int i=l, j=m+1, k=l;			// Zähler Initialisieren (k Hilfsarray, i=Anfang Folge 1, j=Anfang Folge 2

	int *b = new int [r];			// Hilfsarray b Deklarieren (zum Zwischenspeichern;
									// Größe: Gesamte größe der zu sortierenden Folge

	while(i<=m && j<=r){				// Sollange beide Folgen nicht durchlaufen sind ...
		if(a[i]<a[j]){					// ... vergleichen (Wert Folge 1 < Wert Folge 2)
			b[k]=a[i];					// Kleineren Wert in B zwischen Speichern
			i++;
		}else{
			b[k]=a[j];
			j++;
		}
		k++;
	}

	if (i>m){												//wenn i>m ist ist die linke teilfolge also [l...m] durchlaufen
		for(int z=j; z<=r;z++)								//Denn rest der Teilfolge [m+1...r] durch-
			b[k++]=a[z];									//laufen und in array b übertragen

	}else{													//die rechte teilfolge also [m+1...r] ist durchlaufen
		for(int z=i; z<=m;z++)								//Denn rest der Teilfolge [l...m] durch-
			b[k++]=a[z];									//laufen und in array b übertragen
	}

	for(int h=l;h<=r;h++)									// in b gespeicherte sortierte
		a[h]=b[h];											// folge in array a kopieren

	delete [] b;
}
    0
  • B

    Mit tabelle meisnt du das:

    int *b = new int [r];            // Hilfsarray b Deklarieren (zum Zwischenspeichern;

    ??

    und mit löschen meinst du das:

    delete [] b;

    ??

    Woran erkennst du ob er das nicht löscht?

    P.S: du weist schon da ein Array mit 10 Elemente ein index 0 bis 9 hat!?

    0
  • L

    1. Wähle vernünftige Bezeichner! In spätestens einer Woche weißt Du selbst nicht mehr, was i, j, k, l, f und g waren. Wir wissen es erst recht nicht.

    2. "Allerdings lässt sich die so erstellte Tabelle nicht mehr Löschen" ist ungefähr so akkurat wie "Leider fährt mein Auto nicht". Woran glaubst Du zu merken, dass sich die Tabelle (welche?) nicht löschen lässt? Fehlermeldungen?

    3. (Kannst Du nichts für, eher der Prof) In C++ gibt es wesentlich schönere Möglichkeiten als new/delete, gerade für Mengen integraler Typen. Nur Interessehalber: Wie sieht Eure main-Signatur aus? 🤡

    0
  • B

    die siehgt sicher

    void main(void);

    aus 👍 😃

    0
  • A

    Hab mal den Kompleten Code angehängt. "In meinem Stil" verwende ich als Schleifenzähler Grundsätzlich i j und k und immer in jeder Schleife die selben Buchstaben. Ich komm damit klar, andere weniger *g*.

    Meine Bezeichner, ok ich geb zu "l" "r" und "m" sind in sofern nich ganz Eindeutig: l steht für links (Startwert der Sortierung) r steht für Rechts (Endwert der Sortierung, also ist l€[l...r] die größe meines Arrays das es zu Sortieren gilt) und m ist die Mitte der Folge.

    Und ja mit "Tabelle" hab ich Fälschlicherweise

    int *b = new int [r];

    Gemeint, mit Löschen das

    delete [] b

    .

    Worran ich Erkenne das er nicht Löscht? Daran:
    [img=http://img141.imageshack.us/img141/4107/screenfz6.th.jpg]

    Stellt sich mir die Frage wo das Problem liegt 🙂

    Und ja ich weis der Algorithmus is nich der beste, aber Sortieralgorithmen fallen mir als Programmier"anfänger" (mit bisserl erfahrung) etwas Schwer und ich bin froh das ich neben dem ganzen anderen Käse den es zu bewältigen gilt die Aufgabe überhaupt zum Laufen gebracht habe!

    Hier noch der gesamte Quelltext:

    #include <iostream>

using namespace std;

void merge(int a[], int l,int m,int r){
	int i=l, j=m+1, k=l;			// Zähler Initialisieren (k Hilfsarray, i=Anfang Folge 1, j=Anfang Folge 2

	int *b = new int [r];			// Hilfsarray b Deklarieren (zum Zwischenspeichern;
									// Größe: Gesamte größe der zu sortierenden Folge

	while(i<=m && j<=r){				// Sollange beide Folgen nicht durchlaufen sind ...
		if(a[i]<a[j]){					// ... vergleichen (Wert Folge 1 < Wert Folge 2)
			b[k]=a[i];					// Kleineren Wert in B zwischen Speichern
			i++;
		}else{
			b[k]=a[j];
			j++;
		}
		k++;
	}

	if (i>m){												//wenn i>m ist ist die linke teilfolge also [l...m] durchlaufen
		for(int z=j; z<=r;z++)								//Denn rest der Teilfolge [m+1...r] durch-
			b[k++]=a[z];									//laufen und in array b übertragen

	}else{													//die rechte teilfolge also [m+1...r] ist durchlaufen
		for(int z=i; z<=m;z++)								//Denn rest der Teilfolge [l...m] durch-
			b[k++]=a[z];									//laufen und in array b übertragen
	}

	for(int h=l;h<=r;h++)									// in b gespeicherte sortierte
		a[h]=b[h];											// folge in array a kopieren

	delete [] b;
}

void mergesort(int a[], int l, int r){						// a[]=Tabelle, l=Startwert der Folge im Array, r= Ende der Folge
	if(l<r){												// Anfang und Ende liegen Re-Li und nicht Li-Re
		int m=(l+r)/2;										// Halbieren der Gesamten Folge
		mergesort(a, l, m);									// Linken Teil sortieren
		mergesort(a, m+1, r);								// Rechten Teil sortieren
		merge(a, l, m, r);									// Mischen der Teilfolgen
	}
}

void main(){
	const int max=1000;
	// 1.000, 10.000, 100.000 und 200.000 Testinhaltsmengen
	int A[max];
	for(int i=0; i<max; i++)
		A[i]=rand();

	mergesort(A,0,max-1);

	for(int i=0; i<max; i++){
		cout << A[i] << endl;
	}

	system("PAUSE");
}
    0
  • T

    Die Fehlermeldung bedeutet, daß du dir den Speicher zerschossen hast!

    Du schreibst auf Speicherbereiche außerhalb des definierten Bereichs deines Array. Du darfst nur auf die Indizes 0 bis (r-1) zugreifen, d.h.

    for(int h=0;h<r;h++) // in b gespeicherte sortierte
   a[h]=b[h];        // folge in array a kopieren

    Evtl. sind noch andere Fehler drin...

    0
  • A

    Ja da muss ich dir recht geben. Allerdings hatte ich in meiner Version bevor ich auf die Gloreiche Idee kam ein Array mit Pointern zu machen dieses stehen:
    [cpp]int b[4000]; // Doppelte Größe des Urarrays[/b]

    Weis auch nich wieso, anders hats aus mir unbekannten gründen nicht Funktioniert.

    Wenn ich überall "zähler<=r" durch "zähler<r" ersetze, läuft zwar das Programm, nur die Sortierung wirft immer mal wieder einen wesentlich kleineren Wert dazwischen 😕

    Bin da doch rel. Ratlos...

    0
Anmelden zum Antworten