Newsgroup: it.comp.lang.c++
Titolo: Come disallocare un char**?

Mi trovo in questa situazione
void main (void)
{
  int i = 0;
  char **argv = (char **) calloc (5, sizeof(char *));
  for (i = 0; i < 5; i++)
  {
    argv[i] = (char *) calloc (8, sizeof(char));
    sprintf(argv[i], "PROVA %i", i);
  }
  /***** disalloco *****/
 for (i = 0; i <5; i++)
 {
   free((void *) argv[i]);
 }
 free((void *) argv);
}
Dove sbaglio? il compilatore uscendo mi dice che c'è lo stack corrotto.
in particolare uso il vc++ della ms ma non credo sia piattaforma/ide 
dipendente o si? 

 dipendente o si? 
No, fa parte dello standard del linguaggio.
ciao
Giacomo

 free((void *) argv);
Niente cast.

questo probabilmente incasina lo stack.
Il problema è sicuramente nell'allocazione di memoria (insufficiente).
Non è necessario specificare un valore di ritorno per main().
Con un compilatore non conforme con lo standard, void come tipo di
ritorno porta a un comportamento indefinito, mentre VC++ mi sembra lo
supporti, quindi, male che vada, il sistema operativo riceve un valore
sballato come codice d'uscita, ma non si "corrompe" nulla.  Per un
sistema compliant, invece, anche non specificando nulla, viene
aggiunto automaticamente un "return 0;".

 void main (void)
E per forza ti da errore...
La dichiarazione corretta e completa della main è
int main(int argc, char **argv)
in pratica stai usando due variabili dello standard C riservate agli 
argomenti della linea di comando senza averle definite correttamente, e 
per giunta RI-definendole altrove :-)
Cmabia nome alle variabili e filerà tutto liscio.

per giunta RI-definendole altrove :-)
Assolutamente no.  I nomi "argc" e "argv" sono appunto semplici nomi.
Che non vadano usati se non per quei contesti nei quali sono riservati
è un conto e siamo d'accordo, ma non si genera nessun bug scrivendo
qualcosa del tipo:
#include <cstdlib>
#include <cstdio>
const int MAXITEMS=5;
const int MAXLENGTH=50;
int main()
{
    int argc;
    char **argv=malloc(MAXITEMS);
 
    for (argc=0; argc<MAXITEMS; argc++) {
        argv[argc]=malloc(MAXLENGTH);
        snprintf(argv[argc], MAXLENGTH, "prova n. %d", argc);
    }
 
    for (argc=0; argc<MAXITEMS; argc++) {
        printf("%s\n", argv[argc]);
    }
 
    return EXIT_SUCCESS;
}

 Non è necessario specificare un valore di ritorno per main().
Certo che no. Io non parlavo di restituire obbligatoriamente un valore, 
ma di dichiarare main come int altrimenti c'e incongruenza tra chiamante 
e chiamato.
ciao
Giacomo

     char **argv=malloc(MAXITEMS);
Occhio, qui stai allocando 5 bytes, non 5 puntatori.
Meglio:
char **argv=malloc(MAXITEMS * sizeof(char*) );
ciao
Giacomo

char **argv=malloc(MAXITEMS * sizeof(char*) );
Non č meglio: č corretto.
Ho scritto il codice al volo, non era controllato. Thanks!

e chiamato.
Non c'è necessariamente incongruenza: dipende dai sistemi.  Hai
estrapolato la mia frase da tutte le righe seguenti: ci sono sistemi,
come il Visual C++ sotto Windows che supportano anche:
 void main()
Questa forma non produce necessariamente programmi errati, può essere
ammessa su determinate piattaforme.  Si consiglia di usare il valore
di ritorno intero solo per portabilità.

 Dove sbaglio? il compilatore uscendo mi dice che c'è lo stack corrotto.
A non usare gli strumenti che il C++ ti mette a disposizione:
#include <vector>
#include <string>
#include <sstream>
int main() {
  std::vector<std::string> > v;
  for ( int i = 0; i < 5; ++i ) {
    std::stringstream ss;
    ss << "PROVA " << i;
    v.push_back(ss.str());
  }
}
Ciao,
Nicola

 nulla, viene aggiunto automaticamente un "return 0;".
Anche con VC++. Ma son due cose diverse. Il tipo di ritorno di
main dev'essere int, e non mai void.
(Ma certo, non è il problema qui.)
--
James Kanze                                           GABI Software
Conseils en informatique orientée objet/
                   Beratung in objektorientierter Datenverarbeitung
9 place Sémard, 78210 St.-Cyr-l'École, France, 
+33 (0)1 30 23 00 34

 "implicit int" non c'è più.
Io ho scritto che non è necessario specificare un valore di ritorno,
non che non è necessario specificare un *tipo* di ritorno.  Il tipo di
ritorno di main() deve essere int, ma non è necessario un return di un
valore intero.