3. Geschwindigkeitstest: Java, dann VB und dann C++

Geschwindigkeitstest: Java, dann VB und dann C++

  • A

    Hallo liebes Forum,

    ich habe letztens einen Geschwindigkeitstest laufen gelassen, weil ich endlich einmal die Differenz zwischen Java, VisualBasic (nativ von 2006) und C++ wissen wollte.
    Ich dachte mir, die Reihenfolge wäre C++, große Leere und dann Java und VB dicht beieinander.
    Es war jedoch anders.

    Die Aufgabe war mittels eines leicht optimierten BubbleSort ein Array mit 100.000 Elementen zu sortieren. Dieses Array war eingangs im ungünstigsten Fall, also genau falsch herum, sortiert.
    Die Ergebnisse waren: Java brauchte 4 Sekunden, VB 9 und C++ 11, gemessen auf einem Surface Pro 3 mit Core i5 und 2,54 GHz pro Kern.

    Jetzt frage ich mich, wie es sein kann, dass Java so einen schlechten Ruf hat und der Platzhirsch in Sachen Geschwindigkeit, wenn man von seinem kleinen Bruder C und Assembler einmal absieht, am schlechtesten abschneidet. Oder ist C++ einfach schlecht bei Speicherzugriffen und Java hat irgendein ausgeklügeltes System, an das C++ und VB mit ihrer Nativität nicht herankommen?

    Liebe Grüße
    Atlan

    0
  • M

    Atlan schrieb:

    Oder ist C++ einfach schlecht bei Speicherzugriffen und Java hat irgendein ausgeklügeltes System, an das C++ und VB mit ihrer Nativität nicht herankommen?

    Oder die viel wahrscheinlichere Variante: dein Test ist Blödsinn.

    0
  • F

    Atlan schrieb:

    Die Ergebnisse waren: Java brauchte 4 Sekunden, VB 9 und C++ 11, gemessen auf einem Surface Pro 3 mit Core i5 und 2,54 GHz pro Kern.

    Spätestens bei so einem großen Zeitunterschied sollte man zunächst einmal sicherstellen, dass man auch tatsächlich das gemessen hat, was man glaubt gemessen zu haben...

    Atlan schrieb:

    Jetzt frage ich mich, wie es sein kann, dass Java so einen schlechten Ruf ...

    ... bevor man zu den Schlussfolgerungen kommt. Durchaus möglich, dass Java in bestimmten Situationen schneller zum Ergebnis kommt. Deutlich mehr als doppelt so schnell bei etwas so trivialem wie Bubblesort riecht allerdings erstmal stark nach noch nicht ganz ausgereifter Methodik.

    (Kann viele Ursachen haben, die ersten die mir einfallen würden: Identische Algorithmen? Zeitmessungsverfahren? Welche Compiler-Optimierungen? Überhaupt welche? Eventuell das Programm in Debugger gestartet? - z.B. der große grüne Startknopf in Visual Studio startet ein Programm standardmässig im lokalen Debugger, was generell um *einiges* langsamer ist).

    Gruss,
    Finnegan

    0
  • V

    Wohl std::vector genommen und Debug-Einstellungen und wenn ich mich recht erinnere, musste man früher auch noch die checked iterators https://msdn.microsoft.com/en-us/library/aa985965.aspx per Hand abschalten selbst im Release-Build.

    0
  • A

    @Mechanics
    Warum ist der Test Blödsinn? Hast du eine Begründung dazu?

    @Finnegan
    Ich habe es mehrfach überprüft und konnte keine Fehler finden.
    Die Algorithmen sind identisch.
    Bei Java habe ich mit System.nanoTime() gemessen, bei C++ mit dem QueryPerformanceCounter und das Programm für VB habe ich nicht geschrieben. Die Optimierung bei C++ steht auf Geschwindigkeitsoptimierung, sonst habe ich dort nichts angefasst. Der Test lief mit der Release Version ohne das irgendwas Anderes mitlaufen würde.

    @volkard
    Ich habe mit Arrays gearbeitet aber der Tipp ist gut für die Zukunft. Danke dafür. 🙂

    Gruß
    Atlan

    Hier sind noch einmal die Codes:

    long Main::sortList(int elems) {
	int observedElems = elems; //noch zu behandelnde Objekte
	bool swapped;	//wurde schon gewechselt? Muss nicht initialisiert werden, da in do-while Schleife erledigt
	int aid;	//Hilfsvariable zum Tauschen der Werte

	LARGE_INTEGER StartingTime, EndingTime, ElapsedMicroseconds, Frequency;	//Zeit
	QueryPerformanceFrequency(&Frequency);									//Messung
	QueryPerformanceCounter(&StartingTime);									//starten

	do {
		swapped = false;	//wahrheitsgemäß. Es wurde noch nicht getauscht
		for (int i = 1; i < observedElems; i++) {
			if (array[i - 1] < array[i]) {
				aid = array[i - 1];
				array[i - 1] = array[i];
				array[i] = aid;
				swapped = true;
			}
		}
		observedElems--;	//das gerade eingefügte Element muss nicht mehr überprüft werden; observedElems um einen dekrementieren
	} while (swapped);

	QueryPerformanceCounter(&EndingTime);										//Zeitmessung 
	ElapsedMicroseconds.QuadPart = EndingTime.QuadPart - StartingTime.QuadPart;	//beenden
	ElapsedMicroseconds.QuadPart *= 1000000;									//und
	ElapsedMicroseconds.QuadPart /= Frequency.QuadPart;							//Werte
	return (long) ElapsedMicroseconds.QuadPart;									//verarbeiten
}

    private long[] sortList(){
		int observedElems = array.length;
		boolean swapped = true;
		int aid;
		long[] times = new long[] {System.nanoTime() , 0};

		do{
			swapped = false;
			for (int i = 1; i < observedElems; i++){
				if (array[i - 1] < array[i]){
					aid = array[i - 1];
					array[i - 1] = array[i];
					array[i] = aid;
					swapped = true;
				}
			}
			observedElems--;
		} while (swapped);

		times [1] = System.nanoTime();
		return times;
	}
    0
  • M

    Atlan schrieb:

    @Mechanics
    Warum ist der Test Blödsinn? Hast du eine Begründung dazu?

    Weil es sehr viele Faktoren gibt, die hier eine Rolle spielen könnten, und du beschreibst gar nichts. Da muss man davon ausgehen, dass es Blödsinn ist. Oder meinst du, wir glauben das sofort aufs Wort, wenn jemand einfach so sagt, er hats gemessen, Java ist schneller.
    Das C++ Programm ist für Windows, also könnte z.B. das was Finnegan über Visual Studio geschrieben hat zutreffen. Wenn du das Programm aus VS heraus startest, wird es mit einem Debug Heap Allocator gestartet, auch im Release.

    p.s. Das Programm ist immer noch nicht vollständig, kann man also nicht ausprobieren. Wo kommt das array her, wie wird das initialisiert?

    0
  • M

    Bei solchen kleinen Tests kommt haeufig was anderes raus, als im Realeinsatz. Gerade bei primitives koennen javac und die jvm sehr gut optimieren, aber sobald man dann Objekte verwendet, werden diese im Gegensatz zu C++ eigentlich immer heap-alloziiert, methodenaufrufe laufen ueber vtables, etc.

    Zudem kann man bei C++ auch gerade die paar Prozent Code finden und durchoptimieren, die wirklich kritisch sind, waehrend man sich bei java darauf verlassen muss, dass das schon schnell genug sein wird.

    0
  • V

    Die Ausgabe hängt nicht vom Array und dem Sortieren ab, daher kann das gesamte Sortieren wegoptimiert werden und wir messen möglicherweise nur, welcher Compiler unverschämter ist.

    0
  • A

    @Mechanics
    Meinst du, du zweifelst meine Glaubwürdigkeit an? Ich glaube das ja auch nicht aber diese Zahlen standen auf meinem Bildschirm.
    Was für Faktoren meinst du?
    Ich habe das Programm als Standalone gestartet. Nicht einmal ein Ordner war auf, während des Tests.

    @Martog
    Das es die Optimizer gibt, wusste ich aber ich wäre vom Gegenteil ausgegangen, dass die eher komplizierte Dinge optimieren können und nicht solche eher einfachen Dinge.
    Mit der Optimierung hast du Recht.
    Also wäre es noch einmal interessant eine verkettete Liste zu sortieren? Oder etwas mit vielen Methodenaufrufen (rekursiv einen Baum durchlaufen)?

    @volkard
    Ich habe die zufällige Ausgabe (, die nicht mitgemessen wird) eines Wertes aus dem sortierten Array hinzugefügt und tatsächlich ist die Ausführzeit gestiegen, jedoch nur um 0,2 Sekunden von 4,3 auf 4,5.

    Hier noch mal der gesamte Code. Ich weiß, dass der Startcode nicht der Schönste ist aber er sollte auch keinen Schönheitspreis gewinnen.
    C++:
    Main.h:

    #pragma once

#include<Windows.h>
#include<iostream>
#include<string>
#include<ctime>
#include<Winnt.h>
#include<Winbase.h>

using namespace std;

class Main
{
public:
	Main(int, int);
	~Main();
private:
	void initArray(int elems);
	long sortList(int);
	bool run;
	//long* longArray;
	int* longArray;
};

    Main.cpp:

    #include "Main.h"

Main::Main(int times, int elems)
{
	long* timesEach = new long[times];
	long calcAid = 0;
	cout << "Total times speedtest will run: " << times << endl;
	for (int i = 0; i < times; i++) {
		cout << "Time " << i << " out of " << times << endl;
		cout << "Initializing List" << endl;
		initArray(elems);
		cout << "Finished initializing. List has " << elems << " elements" << endl;
		cout << "Starting sorting" << endl;
		timesEach[i] = sortList(elems);
	}

	for (int i = 0; i < times; i++) {
		calcAid += timesEach[i];
	}
	delete timesEach;

	//double result = (double)((double)calcAid / (double)times) / CLOCKS_PER_SEC;
	double result = (double)((double)calcAid / (double)times);

	cout << "Average time taken for sorting process in Microseconds: " << result << endl;
}

long Main::sortList(int elems) {
	int observedElems = elems; //noch zu behandelnde Objekte
	bool swapped;	//wurde schon gewechselt? Muss nicht initialisiert werden, da in do-while Schleife erledigt
	int aid;	//Hilfsvariable zum Tauschen der Werte

	LARGE_INTEGER StartingTime, EndingTime, ElapsedMicroseconds, Frequency;	//Zeit
	QueryPerformanceFrequency(&Frequency);									//	Messung
	QueryPerformanceCounter(&StartingTime);									//		starten

	do {//do-while-Schleife: Wird mindestens ein mal ausgeführt, aber nur so oft wiederholt, wie die Bedingung stimmt
		swapped = false;	//wahrheitsgemäß. Es wurde noch nicht getauscht
		for (int i = 1; i < observedElems; i++) {	//for-Schleife durchäuft Array von 1 bis observedElems - 1
			if (longArray[i - 1] < longArray[i]) {	//wenn der Wert an der Stelle i - 1 größer ist, als an Stelle i
				aid = longArray[i - 1];	//der Wert von longArray an Ort i - 1 wird in aid geschrieben
				longArray[i - 1] = longArray[i]; //der Wert an Stelle i wird an Stelle i - 1 geschrieben
				longArray[i] = aid;	//der Wert von aid wird an Stelle i geschrieben
				swapped = true;	//wahrheitsgemäß. Es wurde getauscht
			}
		}
		observedElems--;	//das gerade eingefügte Element muss nicht mehr überprüft werden; observedElems um einen decrementieren
	} while (swapped);//Bediungung der do-while-Schleife

	QueryPerformanceCounter(&EndingTime);										//Zeitmessung 
	ElapsedMicroseconds.QuadPart = EndingTime.QuadPart - StartingTime.QuadPart;	//beenden
	ElapsedMicroseconds.QuadPart *= 1000000;									//und
	ElapsedMicroseconds.QuadPart /= Frequency.QuadPart;							//Werte
	return (long) ElapsedMicroseconds.QuadPart;										//verarbeiten
}

Main::~Main()
{
}

void main(int count, char** args) {
	char* input = new char[1];
	int howOften;
	int elems;

	do {
		cout << "Start speedtest?[Y/N]" << endl;
		cin.getline(input, 2);

		if (strcmp(input, "y") == 0 || strcmp(input, "Y") == 0) {
			break;
		}
		else if (strcmp(input, "n") == 0 || strcmp(input, "N") == 0) {
			exit(0);
		}
	} while (true);

	input = new char[20];

	do {
		cout << "How often?" << endl;
		cin.getline(input, 20);
		howOften = atoi(input);
	} while (howOften == 0);

	do {
		cout << "How many elements?" << endl;
		cin.getline(input, 20);
		elems = atoi(input);
	} while (elems == 0);

	new Main(howOften, elems);

	cin.getline(input, 2);

}

void Main::initArray(int elems) {
	delete this->longArray;
	this->longArray = new int[elems];

	for (int i = elems - 1; i >= 0; i--) {
		this->longArray[i] = i;
	}
}

    Java:
    Mainclass:

    import java.util.Scanner;

public class Mainclass {

	public static void main(String[] args) {
		Scanner scan = new Scanner(System.in);
		String str;

		outer:
		while (true){
			str = null;
			do{
				System.out.println("Start speedtest?");
				str = scan.nextLine();
				if (str.toLowerCase().equals("n")) break outer;
			} while (!str.toLowerCase().equals("y") && !str.toLowerCase().equals("n"));

			int elemsAm = 0;
			boolean rightInput = false;
			do{
				System.out.println("How many elements?");
				try{
					elemsAm = scan.nextInt();
					rightInput = true;
				}catch (Exception e){
					rightInput = false;
				}
			} while (!rightInput);

			rightInput = false;

			int times = 0;

			do{
				System.out.println("How often?");
				try{
					times = scan.nextInt();
					rightInput = true;
				} catch(Exception e){
					rightInput = false;
				}
			}while (!rightInput);

			System.out.println("Starting speedtest");
			new Speedtest(elemsAm, times);
		}
		scan.close();
	}
}

    Speedtest.java:

    import java.util.ArrayList;

public class Speedtest {
	private int[] array;
	private ArrayList<Long> list;

	public Speedtest(int lengthList, int times){
		list = new ArrayList<Long>(times);
		for (int i = 0; i < times; i++){
			System.out.println("Initializing list");
			initList(lengthList);
			System.out.println("List initialised");
			System.out.println("Starting sorting");
			long[] startEnd = sortList();
			System.out.println("Sorting finished");
			System.out.println("Time: " + (startEnd[1] - startEnd[0]));
			list.add(startEnd[1] - startEnd[0]);
		}

		long result = 0;
		for (int i = 0; i < list.size(); i++){
			result += list.get(i);
		}
		System.out.println("Average time in Microseconds: " + (result / times) / 1000);
	}

	private void initList(int lengthList){
		this.array = new int[lengthList];
		for (int i = lengthList - 1; i >= 0; i--){
			this.array[i] = i;
		}
	}

	private long[] sortList(){
		int observedElems = array.length;
		boolean swapped = true;
		int aid;
		long[] times = new long[] {System.nanoTime() , 0};

		do{
			swapped = false;
			for (int i = 1; i < observedElems; i++){
				if (array[i - 1] < array[i]){
					aid = array[i - 1];
					array[i - 1] = array[i];
					array[i] = aid;
					swapped = true;
				}
			}
			observedElems--;
		} while (swapped);

		times [1] = System.nanoTime();
		return times;
	}
}
    0
  • Mod

    Atlan schrieb:

    @Mechanics
    Meinst du, du zweifelst meine Glaubwürdigkeit an? Ich glaube das ja auch nicht aber diese Zahlen standen auf meinem Bildschirm.
    Was für Faktoren meinst du?

    Hier kommt alle paar Monate jemand mit genau dem gleichen Beitrag wie deinem vorbei. Bis jetzt hat sich jedes Mal herausgestellt, dass sie katastrophale Anfängerfehler bei ihren Messungen gemacht haben (Meistens waren es fehlende Compileroptimierungen/Debugeinstellungen. Niemanden interessiert es, wie schnell unoptimierter Code läuft). Eine gesunde Skepsis ist daher angebracht. Da du in deinem ersten Beitrag keinerlei Details genannt hattest, konnte man aber nichts genaueres sagen.

    0
  • A

    @SeppJ
    Wie kann ich diese Fehler denn überprüfen und ggf. beseitigen?
    Das hier alle paar Monate jemand vorbeikommt wusste ich nicht. Ich bin hier zum ersten Mal seit 2 Jahren online.
    Dann kann ich auch gleich die erwünschten Details posten.

    Gruß
    Atlan

    0
  • Mod

    Atlan schrieb:

    @SeppJ
    Wie kann ich diese Fehler denn überprüfen und ggf. beseitigen?

    Indem du genau und nachvollziehbar beschreibst, was du gemacht hast. Was du mittlerweile ja auch getan hast.

    Ich persönlich habe bloß keine Lust, mir dein Codemonstrum anzutun, daher halte ich mich inhaltlich aus dem Thread raus.

    0
  • V

    Ich habs mal für gcc compilierbar gemacht.

    #include <iostream>
#include <ctime>
#include <cstring>
using namespace std;

class Main
{
public:
    Main(int, int);
    ~Main();
private:
    void initArray(int elems);
    long sortList(int);
    bool run;
    //long* longArray;
    int* longArray;
};

Main::Main(int times, int elems)
{
    long* timesEach = new long[times];
    long calcAid = 0;
    cout << "Total times speedtest will run: " << times << endl;
    for (int i = 0; i < times; i++) {
        cout << "Time " << i << " out of " << times << endl;
        cout << "Initializing List" << endl;
        initArray(elems);
        cout << "Finished initializing. List has " << elems << " elements" << endl;
        cout << "Starting sorting" << endl;
        timesEach[i] = sortList(elems);
    }

    for (int i = 0; i < times; i++) {
        calcAid += timesEach[i];
    }
    delete timesEach;

    //double result = (double)((double)calcAid / (double)times) / CLOCKS_PER_SEC;
    double result = (double)((double)calcAid / (double)times);

    cout << "Average time taken for sorting process in Microseconds: " << result << endl;
}

long Main::sortList(int elems) {
    int observedElems = elems; //noch zu behandelnde Objekte
    bool swapped;   //wurde schon gewechselt? Muss nicht initialisiert werden, da in do-while Schleife erledigt
    int aid;    //Hilfsvariable zum Tauschen der Werte

    time_t StartingTime, EndingTime, ElapsedMicroseconds; //Zeit
    StartingTime=clock();                                 //      starten

    do {//do-while-Schleife: Wird mindestens ein mal ausgeführt, aber nur so oft wiederholt, wie die Bedingung stimmt
        swapped = false;    //wahrheitsgemäß. Es wurde noch nicht getauscht
        for (int i = 1; i < observedElems; i++) {   //for-Schleife durchäuft Array von 1 bis observedElems - 1
            if (longArray[i - 1] < longArray[i]) {  //wenn der Wert an der Stelle i - 1 größer ist, als an Stelle i
                aid = longArray[i - 1]; //der Wert von longArray an Ort i - 1 wird in aid geschrieben
                longArray[i - 1] = longArray[i]; //der Wert an Stelle i wird an Stelle i - 1 geschrieben
                longArray[i] = aid; //der Wert von aid wird an Stelle i geschrieben
                swapped = true; //wahrheitsgemäß. Es wurde getauscht
            }
        }
        observedElems--;    //das gerade eingefügte Element muss nicht mehr überprüft werden; observedElems um einen decrementieren
    } while (swapped);//Bediungung der do-while-Schleife

    EndingTime=clock();                                       //Zeitmessung
    ElapsedMicroseconds = (EndingTime-StartingTime)/(double(CLOCKS_PER_SEC)/1000);
    return (long) ElapsedMicroseconds;                                     //verarbeiten
}

Main::~Main()
{
}

int main(int count, char** args) {
    char* input = new char[1];
    int howOften;
    int elems;

    do {
        cout << "Start speedtest?[Y/N]" << endl;
        cin.getline(input, 2);

        if (strcmp(input, "y") == 0 || strcmp(input, "Y") == 0) {
            break;
        }
        else if (strcmp(input, "n") == 0 || strcmp(input, "N") == 0) {
            exit(0);
        }
    } while (true);

    input = new char[20];

    do {
        cout << "How often?" << endl;
        cin.getline(input, 20);
        howOften = atoi(input);
    } while (howOften == 0);

    do {
        cout << "How many elements?" << endl;
        cin.getline(input, 20);
        elems = atoi(input);
    } while (elems == 0);

    new Main(howOften, elems);

    cin.getline(input, 2);

}

void Main::initArray(int elems) {
    delete this->longArray;
    this->longArray = new int[elems];

    for (int i = elems - 1; i >= 0; i--) {
        this->longArray[i] = i;
    }
}

    Dann die lästigen Abfragen aus der main() rausgemacht.

    int main() {
    new Main(5,100000);
}

    Ausgabe

    Total times speedtest will run: 5
Time 0 out of 5
Initializing List
Finished initializing. List has 100000 elements
Starting sorting
Time 1 out of 5
Initializing List
Finished initializing. List has 100000 elements
Starting sorting
Time 2 out of 5
Initializing List
Finished initializing. List has 100000 elements
Starting sorting
Time 3 out of 5
Initializing List
Finished initializing. List has 100000 elements
Starting sorting
Time 4 out of 5
Initializing List
Finished initializing. List has 100000 elements
Starting sorting
Average time taken for sorting process in Microseconds: 8506.4

    Ok, 8500ms. Mal an den Code gehen und die schlimmsten Sachen normalisieren.

    int main() {
    Main(5,100000);
}

    Ausgabe

    Total times speedtest will run: 5
Time 0 out of 5
Initializing List
*** Error in `/home/…/bin/Release/tmpcpp': munmap_chunk(): invalid pointer: 0x0000000000400ba0 ***
======= Backtrace: =========
/lib64/libc.so.6(+0x726b3)[0x7f618f1cd6b3]
/lib64/libc.so.6(+0x77fa6)[0x7f618f1d2fa6]
/home/…/bin/Release/tmpcpp[0x400f45]
/home/…/bin/Release/tmpcpp[0x400b46]
/lib64/libc.so.6(__libc_start_main+0xf0)[0x7f618f17b630]
/home/…/bin/Release/tmpcpp[0x400bc9]

    Das ist natürlich keine Basis für Vergleiche.

    0
  • M

    Atlan schrieb:

    @Martog
    Das es die Optimizer gibt, wusste ich aber ich wäre vom Gegenteil ausgegangen, dass die eher komplizierte Dinge optimieren können und nicht solche eher einfachen Dinge.
    Mit der Optimierung hast du Recht.
    Also wäre es noch einmal interessant eine verkettete Liste zu sortieren? Oder etwas mit vielen Methodenaufrufen (rekursiv einen Baum durchlaufen)?

    kannst du machen, aber auch dabei wirst du nichts aussagekraeftiges herausbekommen. Nach meiner Meinung ist es am besten, ein richtiges, wartbares Programm in jeder Sprache einmal zu schreiben und dabei auch die relevanten Sprachfeatures zu nutzen, also nicht einfach nur abzuschreiben, und dann verschiedene Teile zu "benchmarken".

    0
  • V

    Atlan schrieb:

    @Martog
    Das es die Optimizer gibt, wusste ich aber ich wäre vom Gegenteil ausgegangen, dass die eher komplizierte Dinge optimieren können und nicht solche eher einfachen Dinge.
    Mit der Optimierung hast du Recht.

    Also mach die alle Optimierungen an und schau dann nochmal.
    Bei mir hüpft dann die Zeit von 26000ms auf 7700ms.

    Atlan schrieb:

    Also wäre es noch einmal interessant eine verkettete Liste zu sortieren? Oder etwas mit vielen Methodenaufrufen (rekursiv einen Baum durchlaufen)?

    Weder noch. Verkettete Listen sortiert man eh nicht. Rekursiv einen Baum zu durchlaufen testet auch nur die RAM-Geschwindigkeit, das Methodenaufrufen ist im Vergleich zu billig.

    0
  • A

    @volkard
    Was meinst du mit normalisieren?
    Wo der Fehler mit dem Pointer herkommt, kann ich mir nicht erklären. Eigentlich müsste alles beschützt sein und keine AccessViolations oder sonstige unzulässigen Zugriffe versucht werden.

    @Marthog
    Was könnte man da denn nehmen? Den Huffman Code?

    @volkard
    Ich habe alle Einstellungen eingestellt, die ich gefunden habe.
    Wo finde ich die Optimierungen denn? Vielleicht habe ich ein paar übersehen.

    0
  • N

    Atlan schrieb:

    Wo der Fehler mit dem Pointer herkommt, kann ich mir nicht erklären.

    Von den Pointern. Genauer: Der Benutzung von new[] für dynamische int Arrays, anstatt vernünftig RAII Wrapper wie std::vector oder von mir auch aus std::unique_ptr<int[]> zu benutzen.

    Eigentlich müsste alles beschützt sein und keine AccessViolations oder sonstige unzulässigen Zugriffe versucht werden.

    Und wieso löscht dann init-Array als erstes das Array (noch dazu mit delete, was falsch ist), ohne irgendwie zu überprüfen, ob bereits eins erstellt wurde? (was beim ersten Mal nicht der Fall ist).
    Mit der Verwendung von RAII Wrappern wäre das nicht passiert.

    0
  • ?

    Atlan schrieb:

    Wo der Fehler mit dem Pointer herkommt, kann ich mir nicht erklären. Eigentlich müsste alles beschützt sein und keine AccessViolations oder sonstige unzulässigen Zugriffe versucht werden.

    Kommt wahrscheinlich hier her:

    delete this->longArray;

    Dein longArray wird nirgendwo initialisiert und du versuchst so irgendeinen zufälligen Speicherbereich zu löschen.

    0
  • T

    ...und da bei dir wohl Speicher auf dem Heap ausgenullt wird, bei Stack aber nicht und da ein delete auf einen nullptr keine Auswirkung hatt.

    0
  • M

    Atlan schrieb:

    @Mechanics
    Meinst du, du zweifelst meine Glaubwürdigkeit an? Ich glaube das ja auch nicht aber diese Zahlen standen auf meinem Bildschirm.
    Was für Faktoren meinst du?

    Wurden doch schon genügend genannt. Fängt mit so simplen Sachen wie Debug oder Release an, nichts davon stand in deinem ersten Beitrag.

    0
Anmelden zum Antworten