Newsgroup: it.comp.lang.c++
Titolo: matrice di calssi

ciao!
mi serve una matrice bidimensionale di classi;
in fase di compilazione non sono note le dimensioni (X,Y) della
matrice ma è noto il massimo che ciascuna dimensione può raggiungere;
per una serie di motivi non farò allocazione dinamica
class myClass {
int index;
public:
myClass(int i);
~myClass();
};
// CONSTRUCTOR
myClass::myClass(int i) {
index=i;}
// DESTRUCTOR
myClass::~myClass(int i) {}
#define MAX_X 2
#define MAX_Y 3
questo codice da errore in compilazione dato che il costruttore
richiede 1 parametro:
myClass matrix[MAX_X][MAX_Y];
così compila ma sono legato alle #define:
myClass matrix[MAX_X][MAX_Y] = {myClass(0),myClass(0),
myClass(0),myClass(0), myClass(0),myClass(0)};
altrimenti protei aggiungere un costruttore che non accetta parametri
in modo da fare:
myClass matrix[MAX_X][MAX_Y];
è fattibile?
grazie
-ice-

ora la sparo grossa ma una cosa del genere non potrebbe bastarti?
#include <iostream>
using namespace std;
template <class T, int ROW, int COL>
class array2d
{
  T memblock [ROW][COL];
  public:
  void set (int x, int y, T value)
  {
    memblock[x][y]=value;
  }
  T get (int x, int y)
  {
    return memblock[x][y];
  }
};

 using namespace std;
<cut>
quale sarebbe la differenza sostanziale?
che è un'implementazione più "astratta"?
non so però se riesco ad implementarla sotto eVC++ 4.0 (embedded
insomma)
hai esperienza a riguardo?
nel mentre ho provato ad aggiungere alla classe un costruttore che non
necessita di parametri e ho aggiunto un metodo per settare il
parametro che prima passavo al costruttore;
usando *** myClass matrix[MAX_X][MAX_Y]; *** funziona perchè tutte le
classi della matrice vengono create con un chiamata al costruttore che
non necessita di parametri; poi con un ciclo for chiamo il metodo solo
sulle classi che mi interessano e setto il parametro
che limiti/svantaggi ci vedi nella mia soluzione rispetto a quella che
proponi tu?
grazie molte
-ice-
ho provato ad aggiungere un costruttore

 
che i template li puoi usare pure con i tipi base e generalmente
producono codice pi� ottimizzato.
In campo microdevice ho esperienza solo in java (e un pochino in C)
quindi non so che dirti.

 ho provato ad aggiungere un costruttore
Faccio un aggiunta...
Il tuo approccio � alla java dove le classi sono risolte a runtime,
mentre per i template il C++ a tempo di compilazione crea una struttura
tarata sul tipo che gli hai passato in costruzione, quindi hai
performance migliori, ma ovviamente hai un sideeffect che se usi lo
stesso template con 4,5 tipi/classi diversi/e hai un eseguibile dove ci
sar� il codice del template tipizzato X volte. (comunque di solito �
poco percettibile questo incremento di size dell'exe.)

 Il tuo approccio è alla java dove le classi sono risolte a runtime,
OK
ho provato a sovradimensionare la matrice con milioni di elementi e mi
viene segnalato un errore di memoria al momento dell'esecuzione;
questo credo sia normale sia in C++ che in java perchè la ram per la
matrice deve essere allocata in qualche modo
d'altra parte però se il programma gira significa che tutta la memoria
di cui ha bisogno l'ha già riservata per se (come se la dovesse usare
tutta);
magari poi ne usa meno ma almeno non mi devo preoccupare se ci sarà
memoria sufficiente per allocare una nuova classe con una new()
il fatto legato alle migliori prestazioni usando il template nel mio
caso penso non sia percettibile perchè ho pochi elementi
grazie
-ice-