Newsgroup: it.comp.lang.c++
Titolo: allocare dinamicamente array

Ho trovato che per allocare un'array a due dimensioni si deve fare:
(per l'esempio uso il tipo int)
int (*array) [10];
array = new [20[10];
volendo, si puo' fare anche 
array = new [numR][10];
Ma ho notato che non si puo' fare
array = new[numR][numC];
C'e' qualche modo per allorare dinamicamente un'array bidimensionale
con le dimensioni in variabili?
Grazie
--
Scritto da Gordon
E-mail: 
tbe...@avpu.vg

 con le dimensioni in variabili?
Dai un'occhiata a questo, s1 e s2 possono avere qualunque valore:
#include <iostream>
int main() {
 int **arr,
  s1 = 2,
  s2 = 3;
 arr = new int* [s1];
 for (int i = 0; i < s1; i++)
  arr[i] = new int[s2];
 for (i = 0; i<s1; i++) {
  for (int j = 0; j<s2; j++)
   arr[i][j] = i+j;
 }
 for (i = 0; i<s1; i++) {
  for (int j = 0; j<s2; j++)
   std::cout << arr[i][j] << ' ';
  std::cout << std::endl;
 }
}
Puoi anche usare un typedef per essere più chiaro:
typedef int * pint;
...
arr = new pint[s1];
Ciao

scusate, ma assumendo che l e r siano 2 variabili int impostate in
qualche modo (input utente o costante, o argomento passato, o quel che
volete).
Non si può semplicemente scrivere
char *array;
int i;
int j;
array = new char [l][r];
for (i = 0, j = 0; i < l, j < r; i++, j++) {array[i] = i; array[j] =
j;}
Ed avere il vostro bell'array bidimensionale dinamicamente allocato?

Cielo che testa di rapa, avete appena detto che non si può fare ^^ Scusate =P
Piuttosto, il programma che avete proposto non mi è chiaro. Cosa fa precisamente?

 ha scritto nel messaggio
news:34e32791.03061...@posting.google.com...

#include <iostream>
int main() {
 int **arr,
  s1 = 2,
  s2 = 3;
// alloca un array di puntatori a int di dimensione s1
 arr = new int* [s1];
// per ogni elemento dell'array alloca lo spazio necessario
// a contenere il tipo di dato
 for (int i = 0; i < s1; i++)
  arr[i] = new int[s2];
Il resto mi sembra chiaro: riempie l'array e stampa i valori.
Ciao

  arr[i] = new int[s2];
non ci avevo pensato ^___^ (sono ancora un po' niubbio;P)
Grazie, era proprio quello che cercavo ;


arr[i] = new int[s2];
Ma questa istruzione praticamente alloca un nuovo array per ogni i di
arr? Mi sembra pesantuccia come soluzione, o no?

 arr? Mi sembra pesantuccia come soluzione, o no?
Secondo me dichiarare un array di array, o meglio ancora un
vector<vector<int>> è la soluzione migliore per rappresentare una matrice.
In alternativa:
template<typename T>
class matrix
{
private:
 T* mat;
 int sa;
public:
 matrix(int a, int b):mat(new T[a*b]),sa(a),sb(b) {}
 ~matrix() {delete[] mat;}
 T& elem(int a, int b) {return (mat[a+(b*sa)]);}
};
int main()
{
 int a=11;
 int b=11;
 matrix<int> m(a,b);
 int c1, c2;
 for(c1=0;c1<a;c1++)
  for(c2=0;c2<b;c2++) m.elem(c1,c2)=c1*c2;
 for(c1=0;c1<a;c1++,cout<<endl)
  for(c2=0;c2<b;c2++) cout<<setw(2)<<m.elem(c1,c2)<<" ";
 cout<<endl;
 return 0;
}
però in questo caso non posso usare l'operatore di subscript perchè accetta
un solo parametro.
Se si vuole per forza usare la sintassi m[1][2] credo che l'unica soluzione
sia l'array di array (o vector<vector<int>>)
Si potrebbero aggiungere molti metodi alla classe matrix ma in anche in
questo caso non è conveniente reinventare la ruota.
--
Gabriele Palma.
Futuro (forse) Ingegnere Informatico.
Secondo il determinismo tecnologico, l'invenzione è una variabile esogena
che successivamente influenza quelle endogene [tratta dai lucidi di un corso
di economia].
Questa signature rimarrà invariata finché qualcuno non mi spiegherà
gentilmente il significato di questa frase.

 arr? Mi sembra pesantuccia come soluzione, o no?
È anche l'unica soluzione per quello che vuoi fare; se vuoi fare un'unica
allocazione forse is può allocare un unico blocco di memoria di dimensioni
s1*s2 e poi lo assegni a colpi di reinterpret_cast; credo che possa
funzionare, ma ora non ho il tempo di provare. In alternativa usi la
libreria standard come ti ha suggerito Gabriele.
Ciao

 Ciao
Si credo che sia una soluzione piů elegante

 soluzione sia l'array di array (o vector<vector<int>>)
E' sufficiente che aggiungi alla tua clase un operator[] che restituisca un
T*.
 T* operator[]( size_t i )  { return mat + (sa*i); }
 const T* operator[]( size_t i )  const { return mat + (sa*i); }
Max

 Max
E' vero. Resituisco il sotto array e poi il compilatore applicando
l'operatore di subscript predefinito per le variabili di tipo puntatore
ottiene il dato vero e proprio.
Non ci avevo pensato.