Sterta w stercie ;)

mam takie cos:

typedef struct abc
{
    int *tablica2;
    int zmienna1, zmienna2;
}

potem gdzies w programie robie cos takiego:
abc *tab;
tab = new abc[200];

i jeszcze gdzies dalej ;> :
for(int i = 0; i < 200; i++)
tab[i]->tablica2 = new int[4];

i czy po wywolaniu:

delete tab;

usunie mi tez wszystka tablica2 we wszystkich elementach? czy tez musze forem wpierw deletowac tablica2?

i jeszcze drugie pytanko
new jest dosc wolne... czy calloc jest szybsze[niedlugo sprawdze] a czy nie ma jakiegos jeszcze szybszego rozwiazania?

1. Nie musisz deletować tablicy przez for, wystarczy delete []tablica2; dla prostych typów nawet tylko delete tablica2;

Ale, czy usuwa ją razem ze strukturą - sprawdź debugerem :)

PS> hehe, pomyliłem tab[] z tablica2[] :)

Zupelne skasowanie tego co stworzyles za pomoca new :
[code]
for(int i = 0; i < 200; i++)
delete[] tab[i]->tablica2;

delete[] tab;
[/code]

Jesli jest to aplikacja win32 (pisana w VC++ lub BCB) to czy new czy calloc czy malloc to nie ma znaczenia gdyz i tak pamiec przydziela VMM korzystajac z jednych i tych samych niskopoziomowych funkcji.

A unix/linux? Jak tam to wyglada? z moich testow wynika ze malloc jest szybszy o okolo 30%-40%
Dobra dizeki za odpowiedz ale drugie pytanko tez jest wazne ;> Czy jest jakas mozliwosc zrobienia tego szybciej(ale bez assemblera bardzo prosze...) Bo wywolywanie 1 000 000 razy calloc trwa ok 5-6 s. na P2 350mhz ;(

Sam nie mierzylem czasu new i malloc wiec musze polegac na twoich obliczeniach ;) Ale nie sadze wiec zeby istnial szybszy sposob niz malloc bo te funkcje i tak sa zoptymalizowane pod wzgledem szybkosci i bezpieczenstwa a juz na pewno na linuxie ! 100000x wywolywac calloc to juz wyrazne niechlujstwo programisty bo kazdy komp bedzie mial problem [diabel]

I tu sie mylisz..
idzie to szybciej zrobic...
np:
moja ulubiona metoda: dirty alloc =^^=
zasada jest dosc prosta.. alokujesz duza ilosc pamieci, a potem po prostu zamiast malloc wywolywac, uzyskujesz sobie wskaznik do odpowiedniego miejsca w pamieci zaalokowanej...
przyklad:

#define MEGABYTE 0x10000

int *a, *b;
char *bigmem, *now;

void init( void )
{
bigmem = (char*)malloc( MEGABYTE );
now = bigmem;
}

void *my_alloc( unsigned size )
{
void *temp = now;
now+=size;
return temp;
}

int main( void )
{
init();
a = (int*) my_alloc( sizeof(int) * 10 );
b = (int*) my_alloc( sizeof(int) * 50 );
...
free(bigmem);
}

ofc to jest tylko przyklad, prosty i prymitywny...
zazwyczaj u mnie to wyglada tak:
mam liste pointerow do zaalokowanych buforow pamieci, na poczatku pusta, przy wywolaniu procki do alokacji pamieci sprawdzam czy mam odpowiednio duzo miejsca w zaalokowanym bufforze, jesli nie to tworze nowy, jesli tak, to zwracam pointer, a jesli user chce wiecej pamieci nisz moj pusty bufor ma, to tworze wyjatkowo duzy bufforek tylko dla tego usera..
a potem na koncu sie to czysci...

takie rozwiazanie jest OK tylko w przypadku jesli chodzi nam o szybkosc, i jestesmy pewni ze wkoncu nie zaalokujemy calej pamieci (jak widac nie ma tu free nigdzie, tylko na koncu)... ale do malych list or sth sie przydaje i bardzo prace usprawnia...

poza tym mozna tez i free dopisac jesli sie na upartego chce =^^= trudno nie jest

a co do innych trikow
np tworzenie dwu/wiecej wymiarowej tablicy mozna zamiast
int i, j;
j = (int) malloc(5sizeof(int));
for( i = 0; i < 5; i++ )
{
j[i] = (int*) malloc(10sizeof(int));
}
zrobic szybsza wersje
int i, j;
j = (int) malloc(5sizeof(int));
j = (int) malloc(510sizeof(int*));
for( i = 1; i < 5; i++ )
{
j[i] = *j + ( 10 * i );
}

i otrzymujemy O(2) (stale) zamiast O(n) =^^=
przy np 3wymiarowej talbicy 100x100x100 widac roznice =^^=

hmm ... mam nadzieje ze chociaz ON TOPIC napisalem =^^=

a.. ps.. uzycie dirty alloca jest mniej wiecej 7 razy szybsze od normalnego uzycia