Milion elementów struktury. Jak?

Cześć.
Potrzebuje szybkiej pomocy.
Na Algorytmy i Struktury Danych mam zrobić analizę czasów sortowań. Wszystko było by dobrze gdyby nie jeden szkopuł, a mianowicie Pan Profesor zażyczył sobie że elementami nie będzie tablica a struktura. I tu mam problem, jak stworzyć strukturę złożoną z miliona elementów? Milion dlatego ponieważ trzeba zrobić 20 pomiarów i przenieść je na wykres, a wykres nie może być co jeden (jedną jednostkę) tylko podał taki wzór: pow(10, k * 6/19). Więc z tego wzoru maks liczbą jest milion. Proszę o pomoc.

Na pewno nie chodzi o milion pojedynczych struktur?

Wygląda to tak:

 
struct elem {
	int wart;
	int dane;
};

int main() {
   elem tab[100000];
}

a element tej struktury wgląda tak: tab[1] = { wart:10, dane: 982}; tab[2] = { wart:762, dane: 1321} itd, i ja mam sortować po wart a długość tej tablicy (n) którą będę sortował jest równa temu wzorowi co podałem uciętej do długość int.

No, więc w czym problem?

Problem jest w tym ze jak uruchomie ze strukturą milion to program się wiesza zaraz po uruchomieniu :(

https://space.zeo.net/g/3svfe

Co nam po komunikacie błędu? Wrzuć kod.

#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <math.h>
#include <fstream>

using namespace std;

double oblicz(double start, double end);
void generuj(struct elem *tab, int size);
void odwroc(struct elem *tab, int size);
void wstawianie(struct elem *tab, int size);
void wybor(struct elem *tab, int size);
void babelkowe(struct elem *tab, int size);
void quick(struct elem *tab, int left, int right );

struct elem {
	int wart;
	int dane;
};

long int TAB_SIZE = 100000;

int main() {
	cout.setf(ios::fixed);
    cout.precision(10);
    elem tab[TAB_SIZE];
	double dif;
	clock_t start, end;
	srand(time(NULL));
	double time[12];
   
   	ofstream file( "data.txt" );
    
	for(int func = 1; func < 5; func++) {
		for(int test = 1; test < 4; test++) {
			
			for(int k = 0; k < 15; k++) {	
				int TAB_SIZE = pow(10, k* 6/19);
				cout << TAB_SIZE << " ";
				
				start = clock();
				switch(func) {
					case 1:
						if(test == 1) {
							generuj(tab, TAB_SIZE);
							wstawianie(tab, TAB_SIZE);			
						}
						else if(test == 2) {
							wstawianie(tab, TAB_SIZE);
						} else if(test == 3) {
							odwroc(tab, TAB_SIZE);
							wstawianie(tab, TAB_SIZE);
						}
						
					break;
					
					case 2:
						if(test == 1) {
							wybor(tab, TAB_SIZE);
						}
						else if(test == 2) {
							wybor(tab, TAB_SIZE);
						} else if(test == 3) {
							odwroc(tab, TAB_SIZE);
							wybor(tab, TAB_SIZE);
						}
						
					break;
					
					case 3:
						if(test == 1) {
							babelkowe(tab, TAB_SIZE);
						}
						else if(test == 2) {
							babelkowe(tab, TAB_SIZE);
						} else if(test == 3) {
							odwroc(tab, TAB_SIZE);
							babelkowe(tab, TAB_SIZE);
						}
					break;
					
					case 4:
						if(test == 1) {
							quick(tab, 0, TAB_SIZE - 1);
						}
						else if(test == 2) {
							quick(tab, 0, TAB_SIZE - 1);
						} else if(test == 3) {
							odwroc(tab, TAB_SIZE);
							quick(tab, 0, TAB_SIZE - 1);
						}
					break;
				}
				
				end = clock();
				time[0] = oblicz(start, end);
				cout << func << ":\t" <<  time[0] << "\n";
			}
			cout << "\n\n";
		}
	}	
	for(int i = 1; i <= 12; i++) {
		file << time[i-1];
		if(i % 3 == 0) {
			file << "\n";
		} else {
			file << "\t";
		}
	}

	file.close();
	
	//system("pause");
	return 0;
}

double oblicz(double start, double end) {
	return (double)(end - start) / CLOCKS_PER_SEC;
}

void odwroc(struct elem *tab, int size) {
	elem tmp;
	
	for (int i = 0; i < size/2; i++) {
	  tmp = tab[size - i - 1];
	  tab[size - i - 1] = tab[i];
	  tab[i] = tmp;
	}
}

void generuj(struct elem *tab, int size) {
	int i;
	
	for(i = 0; i < size; i++){
		tab[i].dane = (rand() %2000) - 1000;
		tab[i].wart = (rand() %2000) - 1000;
	}	
}

void wstawianie(struct elem *tab, int size)
{
    int j;
    struct elem tmp;
    
    for(int i = 1; i < size; i++) {
        tmp = tab[i];
        
        for(j = i - 1; j >= 0 && tab[j].wart > tmp.wart; j--)
             tab[j + 1] = tab[j];
        
        tab[j + 1] = tmp;
    }
}

void wybor(struct elem *tab, int size){
	int i,j, min;
	struct elem tmp;
	
	for(i = 0; i < size; i++){
	    min = i;
	    for(j = i + 1; j < size; j++){
	        if(tab[j].wart < tab[min].wart)
	           	min = j;
	        	tmp = tab[min];
	            tab[min] = tab[i];
	            tab[i] = tmp;
	    }
	}
}

void babelkowe(struct elem *tab, int size) {
    for(int i = 0; i < size; i++){
        for(int j = 0; j < size - 1; j++) {
            if(tab[ j ].wart > tab[ j + 1 ].wart)
        		swap(tab[ j ].wart, tab[ j + 1 ].wart);
        }
    }
}

void quick(struct elem *tab, int left, int right ) {
    int i = left;
    int j = right;
    struct elem x = tab[( left + right ) / 2];
    do {
        while(tab[i].wart < x.wart)
        	i++;
        
        while(tab[j].wart > x.wart)
            j--;
        
        if(i <= j)
        {
            swap(tab[i].wart, tab[j].wart);
            
            i++;
            j--;
        }
    } while(i <= j);
    
    if(left < j) quick(tab, left, j);
    
    if(right > i) quick(tab, i, right);
    
}

Uprzedzam, jest on brzydki.

W którym momencie się wykrzacza?

No zaraz po odpaleniu, nie wiem w którym dokłanie bo nie mam błędu kompilacji

Przekraczasz pewnie dostępny rozmiar stosu.

Zaalokuj tablicę ręcznie, za pomocą new albo calloc.

Możesz napisać przykład jak? Bo ja przyznam że nie ogarniam C++ :(

elem* tab = new elem[TAB_SIZE];

Dziękuje!!! Działa :) :)