C/C++ » FAQ

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); )

FAQ

4 komentarzy

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.

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).

pootek coś ci się zdrowo po pier**

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ć.