Newsgroup: it.comp.lang.c++
Titolo: Come mai non si può allocare una matrice

Durante lo sviluppo di un programma mi è sorta una domanda:
come mai in C++ non è possibile allocare dinamicamente una matrice ad
esempio con questa istruzione pmat=new int[7][8];  ??
Infondo le matrici sono utilizzate in moltissimi casi, perchè il C/C++
non offre un supporto diretto a questa utilissima struttura dati??
Ciao
Diego the dolphin
-- 
Parafrasando Cartesio, "Digito, ergo sum." (D. Zanga)

 non offre un supporto diretto a questa utilissima struttura dati??
C e C++ offrono l'allocazione dinamica rispettivamente con malloc() (et
similia) e new. Se vuoi un array bidimensionale, ad esempio int [2][5],
basta
int *array = new int[10];
In piu' il C++ offre la comodissima classe std::vector.
Es:
std::vector < std::vector <int> > myVector;
Usa std::vector, e' facile, comodo ed efficiente!
Ciao
Domenico Barra

 non offre un supporto diretto a questa utilissima struttura dati??
Ma il C++ lo offre, sei tu che non hai "colto" la sfumatura :)))
Per allocate una matice devi fare:
int* pmat=new int[7*8];
oppure
int* pmat=new int[7,8];
Bow-wow
Killer

 int* pmat=new int[7,8];
???
Ciao,
Nicola

 int* pmat=new int[7,8];
Errore. Se vale, significa 'new int[8]', ma non ne ho mai provato la
validita', ne' da alcuna parte ho mai letto in proposito.
Ciao
Domenico Barra

 ???
Potenza dell'operatore "virgola" ... bello eh ?
Guarda questo programma...
  #include <iostream>
  int main()
  {
    int *mat=new int[2,2];
    int i,j;
    for (i=0; i<2; i++)
      for (j=0; j<2; j++)
        mat[i,j]=(i+1)*(j+1);
    for (i=0; i<2; i++)
      for (j=0; j<2; j++)
        std::cout << "mat[" << i << "," << j
           << "]=" << mat[i,j] << std::endl;
    delete[] mat;
    return 0;
  }
Output:
   mat[0,0]=2
   mat[0,1]=4
   mat[1,0]=2
   mat[1,1]=4
Zero warning e zero errors; nessun undefined behaviour...
solo che non fa quello che potrebbe sembrare a prima vista
a chi non conosce il C/C++ ... e questo grazie
all'operatore "virgola".
  new int[2,2] --- equivale a ---> new int [2]
      mat[i,j] --- equivale a ---> mat[j]
Andrea
--
----------------------------------------------------------------
 <\___/>  Andrea        email: agriff at tin dot it
 / . . \  "6502"          irc: _6502_@EFNET#italia
(  (")  ) Griffini   homepage: 
http://www.netservers.com/~agriff
Sent via Deja.com
http://www.deja.com/

Non ci avevo pensato!
Ciao,
Nicola

 validita', ne' da alcuna parte ho mai letto in proposito.
Purtroppo vale ed e' equivalente a new int[8]. Anche accedere
a quella che si credere essere una matrice con pmat[i,j] vale
ed e' equivalente a fare pmat[j].
Una volta ho incontrato un compilatore che segnalava qualcosa
come "warning: useless expression with no side effects" in casi
come questo... sicuramente non un errore parlante per chi sta
imparando il C/C++ ma almeno era qualcosa.
Tale warning pero' non salverebbe da cose come
   pmat[f(i),j]
in quanto la presenza di una chiamata alla funzione f potrebbe
giustificare l'uso dell'operatore virgola.
Io non ricordo di aver mai fatto uso dell'operatore virgola al
di fuori di cicli for... (a parte in scherzi come lo scrivere
programmi il meno leggibili possibile).


 validita', ne' da alcuna parte ho mai letto in proposito.
Rispondo solo qui, ma vale anche per le altre :)
Il mio errore e' di non aver provato quello che ho scritto :)
Ho letto questa risposta su questo NG un paio di giorni fa
(il discorso e' :"Dichiarazioni matrici" del 15/01/2001 alle 19:48,
 la risposta e' di << Lello Mele >> del 15/01/2001 alle 23:31).
Nessuno aveva obbiettato al suo listato dove c'e' scritto :
        int a=10;
        int b=20;
        int *p= new int[a,b]; // definisce un array dinamico di dimension a*b
percio' ho pensato fosse giusto....
Ma da quel che capisco leggendo questa discussione, in realta' non viene creato
una matrice ma un array, giusto?
Allora mi scuso: la prossima volta diro' solo cose che ho provato sulla mia pelle :)
Bow-wow
Killer

 una matrice ma un array, giusto?
Piu' precisamente, l'array creato con new e' sempre lineare (a una sola
dimensione); d'altra parte l'uso degli array multidimensionali e'
semplicemente una scorciatoia: il compilatore alloca sempre memoria "in
linea", mai "su piu' dimensioni", e interpreta gli indici tra parentesi
quadre in base alle dimensioni dichiarate dell'array :-).
Ciao
Domenico Barra

 quadre in base alle dimensioni dichiarate dell'array :-).
Si, questo lo sapevo (almeno un po' di C prima del C++ l'ho fatto :) ).
Riformulo meglio la mia domanda:
"Facendo qualcosa del tipo:
int* pInt=new int[5,6];
viene creato una matrice (cioe' un array di 5*6 elementi) o un
array di 6 elementi?
Da quel che ho letto, la risposta esatta e' la seconda, giusto?
"
Cosi' dovrei aver reso meglio la mia richiesta :)
Grazie
Bow-wow
Killer

 Da quel che ho letto, la risposta esatta e' la seconda, giusto?
Giusto. Il 5 viene ignorato. Diverso sarebbe stato se avessi scritto:
int x;
int *pInt = new int[x=5,x];
Qui avrai un array di 5 elementi, perché viene eseguita la prima
espressione, poi valutata la seconda.
Ciao
Domenico Barra

Scusate credo di aver posto male la domanda:
Io in C/C++ posso accedere ad un elemento presente in un array creato
dinamicamente in questo modo:
int* pvett=new int[10];
for (int i=0; i<10;i++)
  pvett[i]=i;
se voglio utilizzare la forma classica (per le matrici) mat[i][j] come
posso fare??
Dichiarare una matrice lo so fare senza problemi ma se ne voglio
allocare una nello Heap e contiunare ad utilizzare la forma classica,
devo utilizzare anche un'altro array composto da array di puntatori ad
interi giusto.
Quindi.... in C/C++ esiste un modo per allocare dinamicamente una
matrice semplicemente facendo:
int* pmat= new int[4][5];   ?????
Oppure devo continuare a "simulare" la matrice tramite un'altro
array??
Perchè in C/C++ non è possibile allocare dinamicamente una matrice con
la semplice parola chiave "new"???
Grazie


 la semplice parola chiave "new"???
Probabilmente perche' un puntatore e' sempre una matrice ad una
dimensione, come lo e' la memoria degli elaboratori elettronici.
Ovviamente e' solo la mia ipotesi.
    Aldo.