Zunehmender Stapel funktioniert nicht

Question

Wie kann ich den verfügbaren Stapel für ein Programm mit Bloodshed Dev C++ oder Code :: Block richtig erhöhen? Ich führe einfache Blase und schnelle Sortierung, die funktionieren, aber wenn ich den Stapel in Code :: Block änderte (fand heraus, wie über here), machte es mein Programm noch schneller zum Absturz, trotz der Verwendung von viel mehr als vorgeschlagenen Raum. Ursprünglich stürzte das Programm beim Sortieren von 64K zufälliger Ganzzahlen ab (unter Verwendung der rand()-Funktion). Jetzt stürzt es bei 32K ab. Ich bekomme den Fehler: Process returned -1073741571 (0xC00000FD)

das Programm läuft tatsächlich schneller ohne den Stapel geändert zu haben, vorausgesetzt, ich mache es richtig. gcc -Wl,--stack,1099511627776

ich kann nicht herausfinden, wie es in Dev C überhaupt ändern ++

Was soll ich tun? Gibt es eine Möglichkeit, den Stack innerhalb des Codes selbst zu ändern? hier ist der Code im für Blase und schnelle Sortierung. Es gibt jeweils zwei: Einer ist mit Vektoren, der andere mit Arrays. Ich denke, dass die Blase sortieren. sollte stimmen. die schnelle Sorte, ich bin mir nicht so sicher. Leider Wenn es ein bisschen chaotisch

vector <int> v_bubble(vector <int> array){ 
    // Vector Bubble Sort 
    if (array.size() < 2){ 
     return array; 
    } 
    int s = 1; 
    while (s){ 
     s = 0; 
     for (unsigned int x = 0; x < (array.size() - 1); x++){ 
      if (array[x] > array[x + 1]){ 
       int t = array[x]; 
       array[x] = array[x + 1]; 
       array[x + 1] = t; 
       s = 1; 
      } 
     } 
    } 
    return array; 
} 

void a_bubble(int array[], int size){ 
    // Array Bubble Sort 
    int s = 1; 
    while (s){ 
     s = 0; 
     for (int x = 0; x < (size - 1); x++){ 
      if (array[x] > array[x + 1]){ 
       int t = array[x]; 
       array[x] = array[x + 1]; 
       array[x + 1] = t; 
       s = 1; 
      } 
     } 
    } 
} 

vector <int> v_quick(vector <int> array){ 
    //Vector Quick Sort 
    if (array.size() < 2){ 
     return array; 
    } 
    vector <int> left; 
    vector <int> right; 
    int p_location = array.size()/2 - 1; 
    int pivot = array[p_location]; 
    for(unsigned int x = p_location; x < array.size() - 1; x++){ 
     array[x] = array[x + 1]; 
    } 
    array.pop_back(); 
    for(unsigned int x = 0; x < array.size(); x++){ 
     if (array[x] <= pivot) { 
      left.push_back(array[x]); 
     } 
     else if (array[x] > pivot){ 
      right.push_back(array[x]); 
     } 
    } 
    vector <int> p; 
    p.push_back(pivot); 
    return combine(combine(v_quick(left), p), v_quick(right)); 
} 

int a_quick(int array[], int size, int l_index = -1, int r_index = -1){ 
    //Array Quick Sort 
    if (size < 2){ 
     return array[size]; 
    } 
    array[size] = array[size]; 
    int left[size]; 
    int right[size]; 
    l_index = 0; 
    r_index = 0; 
    int p_location = size/2 - 1; 
    int pivot = array[p_location]; 
    for(int x = p_location; x < size - 1; x++){ 
     array[x] = array[x + 1]; 
    } 
    size--; 
    for(unsigned int x = 0; x < size; x++){ 
     if (array[x] <= pivot) { 
      left[l_index] = array[x]; 
      l_index++; 
     } 
     else if (array[x] > pivot){ 
      right[r_index] = array[x]; 
      r_index++; 
     } 
    } 
    return a_quick(left, l_index, l_index, r_index) + pivot + a_quick(right, r_index, l_index, r_index); 
} 

der Rest des Codes einfach ist Arrays und Vektoren, die mit 32, 64 und 128 k Einträge, Sortieren sie unter Verwendung des obigen Code und Rückführen der Zeit zu erzeugen. dass ein Teil im ziemlich sicher, dass ich vermasselte nicht

mein Haupt ist im Grunde nur

start = clock(); 
    a_quick(array1, 32000); 
    end = clock(); 
    cout << "\nQuick Sort\tArray\t32000\t" << ((double) end - start)/CLOCKS_PER_SEC << " seconds\n"; 

immer und immer wieder

Answer 1

Es sei denn, Sie für eine sehr speicherbeschränkte Embedded-Umgebung sind die Programmierung, vermute ich, Sie haben einen Rekursionsfehler in Ihren Sortierimplementierungen, der Stapelüberlauf verursacht. Das Ändern der Stapelgröße sollte nicht notwendig sein, es sei denn, Sie haben mit wirklich riesigen (viele GB) Arrays zu tun.

Möchten Sie etwas Code posten?

Answer 2

In Funktion int a_bubble(int array[], int size): Sie geben array[size], das ist außerhalb der Grenze. Das gleiche gilt für a_quick().

Und bitte auch Ihre main() bitte.

EDIT: Nein, es gibt das Element nach das letzte Element des Arrays zurück. Manche könnten sagen, dass selbst der Zugriff auf UB ist, und sie hätten Recht.

Ist es Debug-Build Sie laufen? Ich denke, der Fehlercode entspricht "Out of Bound Exception", aber ich verstehe nicht, warum es so kryptisch sein muss.

EDIT2: es ist schlimmer. Was steht für int array[1 << 20]? Die alte Version war in Ordnung, Sie mussten nur return array[size] entfernen. Stellen Sie die Funktionen void zurück, Sie haben bereits beide, Array und seine Größe im aufgerufenen.