Tablice większe niż 65536 bajtów.
yetihehe
Normalne tablice mają ograniczenie do 65536 bajtów wielkości. To nam czasami nie odpowiada.
#include <malloc.h>;
int *liczby;
liczby=malloc(70000*1000); //chcemy mieć na przykład tablicę 256 razy większą, można jeszcze większe, ale cóż, tablica jest [70000][1000]
*(liczby + x*70000 + y)=10; //równoznaczne z liczby[x][y]=10
printf("%d",*(liczby+x*70000+y)); //wydrukowanie zawartości liczby[x][y]
Proste, nie?
Dla tablic więcej wymiarowych trzeba trochę więcej mnożenia:
liczby=malloc(7000*6000*5000); //liczby[7000][6000][5000]
*(liczby+x*7000*6000+y*6000+z)=10;
podobnie postępujemy dla większej ilości wymiarów.
Oczywiście nie zapominamy za każdym razem po użyciu wyrzucić smieci, czyli zwolnić pamięć( free(liczby); )
pootek coś ci się zdrowo po pier******
No według mnie to raczej ładniej i nowocześniej wygląda new i delete zamiast malloc i free - pozostałości z C. Ja bym tą pierwszą pierwotną wersję na górze strony zrobił trochę przyjaźniej wyglądającą i użył cout zamiast printf chociaż wiem, że printf ma dużo większe możliwości, no ale stawiam na prostotę. Poza tym nikt już tego nie przeczyta bo piszę to prawie 2 lata po pierwotnej wersji, a więc:
int * liczby; //zamiast int moze byc inny typ
liczby = new int[rozmiar1][rozmiar2][rozmiar3] /itd. wybrana ilosc rozmiarow byleby sie zmiescilo w rozmiarze free store'a/
liczby[x][y][z] = 1;
delete liczby[][][]; /* bycmoze zamiast tego bedzie delete liczby[];*/
Nie probowalem tego szczerze mowiac. Wiem ze tablice jednowymiarowe tak chodza wiec raczej wielowymiarowe rowniez (logika by na to wskazywala).
A tak to można zrobić dla trybu rzeczywistego, gdzie żadna tablica nie moze przekroczyć 64kB:
int main(){
typ** tablica;
long ilosckomorek=... // twoje dane, wiecej niz 65536, stąd long;
unsigned count=0</cpp>x<cpp>8000/sizeof(typ); // ile komorek miesci sie w 32kB
unsigned j=ilosckomorek%count; // ile komorek w ostatniej tablicy
unsigned i=(ilosckomorek/count)+(j>0); // ile w sumie tablic tablic bedzie
unsigned k=i;
tablica=new(typ*)[i]; // przydzielamy pamiec tablicy tablic
if(j)tablica[--i]=new typ[j]; // ostatnia, niepelna linijka
while(i--)tablica[i]=new typ[count]; * while(i)tablica[--i]=new typ[count]; * pelne linijki.
long l; //- indeks komorki; 0..ilosckomorek-1
typ zmienna;
zmienna=tablica[l/count][l%count];
tablica[l/count][l%count]=zmienna;
while(k--)delete tablica[k]; // zapamietac, zaby wiedziec ile zwolnic
delete tablica;
return 0;
}
0x8000 to rozmiar arbitralnie ustalony... Nie jest to żaden przymus/konstans... Nie może oczywiście jednak przekroczyć 64kB
Zamiast 'new typ[costam]' może byc '(typ*)malloc(costamsizeof(typ))', a zamiast 'new(typ)[costam]' odpowiednio '(typ**)malloc(costamsizeof(typ))'. I w związku z tym zamiast 'delete tablica[costam]' - 'free(tablica[costam])' oraz zamiennie z 'delete tablica' - 'free(tablica)' Ale niestety nie powinno sie mieszać new/free i malloc/delete, bo po pierwsze brzydko to wygląda, po drugie moze nie działać.
Normalne tablice mają ograniczenie do 65536 bajtów wielkości.
To bzdura , nowe i trochę starsze :-) kompilatory 32 bitowe akceptują tablice
o większym rozmiarze.Twierdzenie jest prawdziwe dla kompilatorów 16 bitowych
DOS.