Newsgroup: it.comp.lang.c++
Titolo: Arrays e dimensioni costanti

Il mio problema sta nel fatto che voglio creare una matrice il cui numero
di righe deve essere immesso dall'utente, diciamo da un file input stream. 
Dopo aver definito un oggetto per imettere il valore desiderato, copio il
valore dell'oggetto in un nuovo oggeto costante, e poi uso questo nuovo
oggetto costante per definire una delle dimensioni della mia matrice
In codice:
	int NumberOfBreaks=100;
	int Repeats=100;
	int Intervals=50;
	int MaxSize=1;
 
	if (fin) {
		fin >> NumberOfBreaks >> Repeats >> Intervals >> MaxSize; // Gets the values
		cout << NumberOfBreaks << "\t" << Repeats << "\t" // Outputs them for check.
			<< Intervals << "\t" << MaxSize << endl;
	}
	else {
		clog << "Input File Not Available. Exit." << endl;
		return 1;
	}
	const int Br = NumberOfBreaks;
	const int Rp = Repeats;
	const int In = Intervals;
	const int Ms = MaxSize;
	int Histo[Int][3]; 
a questa punto il compilatore VC++ 6.0 dice che dovrebbe esserci una
costante in Histo [ ] .
Perche' non gli piace Int??
Ciao grazie
Massimo
----------------------------------
Massimo Pinto
Gray Laboratory C.R.T.
pi...@graylab.ac.uk
----------------------------------
--
Posted from 
ntserver.graylab.ac.uk
 [193.61.195.125]
via Mailgate.ORG Server - 
http://www.mailgate.org

 Perche' non gli piace Int??
Perche' si non si puo' dichiarare dinamicamente un oggetto in questo
modo.
Se vuoi fare una dichiaraziore del tipo:
int Histo[Int][3];
Int deve essere una costante.
Se vuoi invece avere un oggetto dinamico devi fare:
int *Histo;
Histo = new (int[Int*3]);
...
Histo[i*3+j]
...
delete[] Histo;
Purtroppo in questo modo pero' perdi lģindirizzamento bidimensionale...
Ciao.
-- 
     (ZZZ)       Filippo Salotti, Bagni di Lucca, Lucca, Italy.
    //   \\  _                 E-mail : 
fil...@humnet.unipi.it
   /Y\    ZD<_o===============================================o
 .oZZZZZo.     | Studente Ingegneria Informatica Automatica  |
<OXXXXXXXO>    | Dip. Sistemi Elettrici Universita' di Pisa. |

Ciao.
si puo` sempre dichiarare un puntatore a puntatore e allocare le dimensioni separatamente:
#include <iostream>
using namespace std;
int main() {
  // costruisce una matrice utilizzando un puntatore
  // a puntatore ed allocando una dimensione alla volta.
  // prima costruisce le righe
  int** Histo = new int*[10];
  // quindi costruisce le colonne:
  for(int i=0; i<10; ++i)
    Histo[i] = new int[3];
  // usa la matrice nel modo usuale...
  for(int j=0; j<10; ++j)
    for(int k=0; k<3; ++k)
      Histo[j][k] = j*k + k;
 
  for(int j=0; j<10; ++j) {
    for(int k=0; k<3; ++k)
      cout << Histo[j][k] << " - ";
    cout << endl;
  }
  char a;
  cin >> a;
  // elimina la matrice una dimensione alla volta;
  for(int i=0; i<10; ++i)
   delete [ ] Histo[i];
 delete[ ] Histo; 
  return 0;
}
Non e` quindi necessario rinunciare all'uso di indici multipli.
Paolo
------------------------------------------------------------------
  Paolo Marotta
  Computer Science, University of Pisa
  home:   
http://www.cli.di.unipi.it/~marotta
  G: Per concludere, possiamo chiedervi di commentare
     l'attuale panorama informatico?
  I: /* l'attuale panorama informatico */
------------------------------------------------------------------

 Non e` quindi necessario rinunciare all'uso di indici multipli.
Sicuramente no! 
Ma nel modo da te indicato si perde la contiguità dell'allocazione che
in alcuni casi e' altrettanto importante e le fasi di allocazione e
deallocazione sono piu' complesse, per questo non avevo suggerito questo
metodo.


metodo.
Ok, pero`il problema della contiguita`  e` tutta un'altra storia...
Mi e` sembrato giusto far notare che non era necessario rinunciare
alla comodita` (anche se normalmente le comodita` si pagano)!
