Newsgroup: it.comp.lang.c
Titolo: Parametri per malloc

Avrei un problema con una malloc per allocare uno spazio in memoria che 
corrisponde ad un puntatore al tipo long, che però deve essere 
moltiplicato, per creare la dimensione voluta, per una variabile locale.
Per la precisione nella funzione di ordinamento mergesort dovrei 
utilizzare i parametri di input (left e right) per creare la dimensione 
dello spazio in memoria da allocare per un vettore temporaneo.
Il problema è che se scrivo:
tmp = (long *) malloc (sizeof(long) * (right-left+1))
dove tmp è il mio puntatore alla locazione desideata, il compilatore 
(djgpp) ritorna un errore di traceback frame o qualcosa del genere, in 
ogni caso è un errore di allocazione della memoria dovuto alla creazione 
di tale spazio.
Se anzichè utilizzare (right-left+1) utilizzo dentro alla malloc una 
costante definita globalmente di 10000 elementi ad esempio funziona tutto.
La mia domanda è: come posso specificare con la malloc la dimensione 
voluta di questo array temporaneo? Ovviamente creando un puntatore con 
la malloc in modo da uscire in caso non si riuscisse ad allocare lo 
spazio richiesto (i.e.   exit(1)  ).
Non credo sia una gran soluzione quella di giocare eccessivamente con 
variabili globali, soprattutto se sono costanti, non ha senso!!!
Ringrazio chiunque mi proponga una soluzione....
Ciao, ALFI!
               ALFREDO DONATI
¤===¤===¤===¤===¤===¤===¤===¤===¤===¤===¤
  \  Undergraduate Student of Computer  /
   \ Science at University of Bologna  /
    ¤==¤===¤===¤===¤===¤===¤===¤===¤==¤
     \    
www.cs.unibo.it/~adonati
   /
      \     
ado...@cs.unibo.it
     /
       \      ICQ# 111878362       /
        ¤===¤===¤====¤====¤===¤===¤
I don't have a license to kill.
I have a learner's permit.

 tmp = (long *) malloc (sizeof(long) * (right-left+1))
Domanda scema: sicuro che l'operazione (right-left+1) dia un valore
positivo o nullo?
Nel caso non sia cosi', scrivila come tmp=blablabla *(abs(right-left)+1)
-- 
Brain fried -- core dumped
*** Don't THINK different, BE different! BeOS.***
http://www.be.com
 
http://www.bugit.org
La mia (penosa, per ora) homepage: 
http://digilander.iol.it/burton666/


right-left+1  va bene solo se:
- right e left sono entrambi pointer a long
AND
- right>=left
AND
- puntano all'interno di un array di long unico, no malloc differenti.
se queste 3 condizioni non sono tutte verificate, non puoi fare cosi'.
consiglio: conta gli elementi che ti servono con una funzione che scorra
la lista/albero e ritorni un int.
ciao
donCiccio

 - right e left sono entrambi pointer a long
Non vedo perche' right e left non potrebbero essere dei
semplici interi.
-- 
Posted from  [80.105.34.80] 
via Mailgate.ORG Server - 
http://www.Mailgate.ORG


gulp! e' vero.
mi hanno confuso i loro nomi.
ciao
donCiccio

Ringrazio tutti per le immediate risposte!!! Grazie davvero :-)
La funzione incriminata in particolare e` la merge e non credo che right 
diventi mai minore di left perche` in tal caso non verrebbe nemmeno 
invocata una successiva chiamata alla merge; la chiamata alla merge 
avviene dentro ad un ciclo:
	while (left<right)
Il vettore e` un vettore di long e basta, non ci sono problemi di 
omogeneita` di tipi al suo interno...
Continuando a riflettere mi e` sorto un altro atroce dubbio!
Non e` che il compilatore cerchi di allocare la malloc immediatamente 
senza prima curarsi di andare a vedere cosa sono left e right?
In tal caso dovrei ricevere dei warnings quanto meno!
Se fosse cosi` non saprebbe cosa allocare, ma mi sembra assurdo!
Riporto il codice della funzione merge per chiarezza:
void merge (long vett[], int left, int mid, int right)
{
    int i,j,h,k;
    long *tmp;
    i=k=left;
    j=mid+1;
    tmp = (long *) malloc (sizeof(long) * (right-left+1));
    if (tmp == (long *)NULL)
    {
       puts("\n\nErrore nell'allocazione della memoria durante la 
creazione del vettore!");
       system("PAUSE");
       exit(1);
    }
    while (i<=mid && j<=right)
    {
       if (vett[i]<=vett[j])
       {
          tmp[k]=vett[i];
          i=i+1;
       }
       else
       {
          tmp[k]=vett[j];
          j=j+1;
       }
       k=k+1;
    }
     if (i<=mid)
        for (h=i; h<=mid; h++)
          tmp[k+h-i]=vett[h];
    for (h=left; h<j; h++)
       vett[h]=tmp[h];
   free(tmp);


 Se fosse cosi` non saprebbe cosa allocare, ma mi sembra assurdo!
La malloc serve solo per allocare la quantità di memoria che tu le dici,
e restituire un puntatore che tu casti, quindi il compilatore non ti
deve dire nulla. Il problema semmai lo puoi avere se la quantità che
passi è un numero negativo, perchè la malloc accetta solo unsigned
values: questo è però un errore di run time, perchè può succedere (nel
caso generale, non nel tuo caso specifico) che la differenza right-left
sia <0, per cui il compilatore non può dire nulla a priori (è per questo
che ti ho consigliato di mettere una verifica).
Ciao,
Cecco

           tmp[k]=vett[i];
tmp deve essere usato con indici da 0 a (right-left) compresi, nel tuo
codice 'k' potrebbe essere fuori dal range.
ciao
donCiccio