Newsgroup: it.comp.lang.c++
Titolo: Altro problemino...

Ho risolto il problema del MCD e svariati altri...ma ora ne ho uno un
po' + garve: non riesco a capire dove sia l'errore in questa funzione per
allocare
la memoria per una matrice.
Il compilatore continua a restituire l'errore "cannot convert void * to
double * in
function alloca_martice(int)."
Allego il codice:
matrice alloca_matrice(int n)
{
  int i;
  double **pa;
  *pa = calloc(n, sizeof *pa);
  if (!pa) return 0;
  for (i=0; i<n; i++) {
    pa[i] = calloc(n, sizeof **pa);
    if (!pa[i])
      for (i--; i>=0; i--)
 free(pa[i]);
      free(pa);
      return 0;
    }
  }
  return pa;
}
Cosa devo fare??
Grazie in anticipo.

 allocare la memoria per una matrice.
Il problema vero e` che usi calloc.  Usa invece std::vector<>, e
avrai meno problemi.
Per "mettere un cerotto", che ti impedisca per ora di vedere la
punta di quell'iceberg di problemi che causi usando calloc, puoi
usare reinterpret_cast<double*>(calloc(n, sizeof **pa)) ecc ecc.
(malloc ha piu` o meno gli stessi problemi di calloc.  I contenitori
standard C++, std::vector<> anzitutto, non hanno questi problemi).
Alex


Sai dirmi precisamente come usare std::vector<>?O magari dove posso trovare
qualche info dettegliata?

 wrote in message news:8jtlaa$lrd$1...@nslave2.tin.it...

I testi piu` dettagliati sui contenitori standard C++, e sulle
loro versioni "STL", sono rispettivamente "The C++ Standard Library",
di Josuttis, e "Generic Programming and the STL", di Austern.  Ma
qualsiasi buon testo di C++ ti da` tutte le informazioni che ti
servono praticamente in merito: ad esempio, il solito "C++ Primer"
di Lippman e Lajoie, che trovi anche in traduzione italiana.
std::vector<> in particolare e` il piu` semplice, e il piu` usato
in pratica, di tutti i contenitori della libreria standard; trovi
qualche appunto in merito anche sulle FAQ di questo gruppo, che a
loro volta trovi visitando 
www.programmazione.it
.  Comunque,
riassumendo all'osso dell'osso...:
* devi avere un #include <vector> per abilitare la funzionalita`;
* dove "alla C" dichiareresti un "pippo* larray;" avrai invece
    std::vector<pippo> larray;
* per dimensionare larray a N elementi scriverai semplicemente
    larray.resize(N);
  che usera` il costruttore di default di pippo per aggiungere
  elementi (se l'aggiunta e` necessaria);
* il distruttore di larray liberera` tutte le risorse consumate
  e distruggera` i pippo contenuti in particolare, quindi non
  ti serve piu` preoccuparti di "cancellare" checchessia;
* useray larray[x] per x da 0 a N-1 per accedere a un elemento;
* hai anche una comoda larray.size() che torna N;
* puoi fare anche tante altre cose simpatiche, ma queste sono
  quelle essenziali e piu` che sufficienti per sostituire un
  attuale uso di puntatori-e-malloc (o calloc).
Un dettaglio: ricorda che il parser C++ usa il "maximal munch"
e quindi se vede ">>" lo prende come un singolo token.  Se hai
template annidati mettici dunque uno spazio, ad es per un
vettore di vettori di double:
    std::vector< std::vector<double> > lamatrice;
senza lo spazio fra i due segni di ">" avresti un errore.
Alex

Scusa se te lo chiedo così bruscamente, ma ho una fretta tremenda: come
faccio a implementare il metodo di Jacobi per la risoluzione di un sistema
di equazioni lineari? Ci ho provato ma non ce l'ho fatta, e ora sono davvero
in crisi. Ho sviluppato tutto il resto del programma (classi, funzioni,
ecc...) ma questa parte proprio non riesco a farla.Cosa devo fare?

 wrote in message news:8juqea$dac$1...@nslave2.tin.it...

Trovi un'ottima spiegazione in pseudo-linguaggio dell'iterazione
di Jacobi alla URL:
 
http://www-rohan.sdsu.edu/faculty/symbol/jacobi_iteration.html
comprese le dovute spiegazioni sui molti problemi di convergenza
dell'algoritmo in questione, nonche`, su:
 
http://www-rohan.sdsu.edu/faculty/symbol/gauss_seidel.html
l'esposizione di Gauss-Seidel per analogia con Jacobi e cenni a
perche` esso e` normalmente preferibile.
Non conosco implementazioni "gia` precotte" in C++ di Jacobi,
ma se proprio devi usare quello (...presumo si tratti di un
esercizio/compito a casa/prova d'esame...?) non dovrebbe
esserti troppo difficile scriverlo partendo dalla suddetta URL.
Alex

  *pa = calloc(n, sizeof *pa);
Se utilizzi il C++ fallo veramente...
std::vector<double> pa;
Es.
pa.push_back(10.5);  // aggiunge un nuovo elemento...
...
pa.push_back(0.6);
double i = pa[5];  // recupera il valore all'indice 5
pa[3] = 7.1; memorizza un valore all'indice 3
Ovviamente sono esempi parziali, nel senso che per
utilizzare il template std::vector<> devi perderci qualche minuto
su un libro o sull'help del tuo compilatore.
una alternativa di piu` basso livello (e piu` laboriosa) e`
utilizzare new[] e delete[]
double** pa = new double*[n];   // quasi equivalente alla calloc
pa[i] = new double[m];
delete[] pa[i];
delete[] pa;
Ma con std::vector, i minuti investiti nello studiarlo si trasformano
in ore di lavoro risparmiate (e deve andarti male per risparmiare solo
ore)!
Nelle faq su 
www.programmazione.it
 trovi parecchie risposte riguardo
all'uso in C++ di array e matrici.
Paolo
--------------------------------------------------
  Paolo Marotta
  Computer Science, University of Pisa
  home:   
http://www.cli.di.unipi.it/~marotta
--------------------------------------------------