Newsgroup: it.comp.lang.c++
Titolo: problema passaggio argomenti a template

Ciao a tutti,
spero di essere nel gruppo giusto per porre la mia questione. Il problema
sorge utilizzando Borland Builder 4.0 pro, ma credo riguardi in generale
aspetti del c++. Si manifesta passando argomenti non costanti ad un
template:
La definizione della classe è la seguente:
//------ beg ---------
#include <stdlib.h>
//----- vettore sicuro
template<class T, int a>
class SecurVect{
private:
        T* root;
        int size;
public:
        SecurVect(){
                if(a < 1){
                        exit(0);
                        }
                root =  new T[a];
                size = a;
                };
        ~SecurVect(){
                delete []root;
                };
        T* RilasciaPuntatore(){
                return root;
                };
        void Rialloca(int a){
                if(a < 1){
                        exit(0);
                        }
                delete []root;
                root =  new T[a];
                size = a;
                };
        T& operator[](int index){
                if(index < 0 || index >= size){
                        exit(0);
                        }
                return root[index];
                };
        };
//---- matrice sicura
template<class T, int a, int b>
class SecurMatrix{
private:
        SecurVect<T, b>* root;
        int size;
public:
        SecurMatrix(){
                if(a < 1){
                        exit(0);
                        }
                root = new SecurVect<T, b>[a];
                size = a;
                };
        ~SecurMatrix(){
                delete []root;
                };
        void Rialloca(int a, int b){
                if(a < 1){
                        exit(0);
                        }
                delete []root;
                root = new SecurVect<T, b>[a]; // errore
                size = a;
                };
        SecurVect<T, b>& operator[](int index){
                if(index < 0 || index >= size){
                        exit(0);
                        }
                return root[index];
                };
};
//---------- end ----------------
Il compilatore dice che SecurMtrix::Rialloca() è sbagliato:
[C++ Error] SecurMatrix.h(72): E2396 Template argument must be a constant
expression.
Quindi non so come cambiare il mio vettore durante l'esecuzione, qualcosa
del tipo:
//---------beg--------------------
SecurMatr<char, 1024, 12> Buff1;
int alpha, beta;
void __fastcall TForm1::Button1Click(TObject *Sender)
{
[...]
while(.....){
        alpha++;
        beta--;
        .....
        }
Buff1.Rialloca(alpha, beta);
[.....]
}
//-------end----------------------
C'è qualcuno in grado di darmi una mano, per favore?
ciao
Claves do Amaral
claves.d...@netbusiness.it

 Quindi non so come cambiare il mio vettore durante l'esecuzione
Se vuoi che le dimensioni cambino a runtime, non devono essere parametri
di template, che sono fissati una volta per tutte durante la
compilazione.
Ciao,
Nicola

 compilazione.
ma allora che parameri debbono essere? Ti ricordo che il costruttore non
ammette argomenti quando viene invocato con l'operatore new.
Ciao e grazie
Claves

 ammette argomenti quando viene invocato con l'operatore new.
Non mi e' chiaro dove sta il problema. Riprendo il tuo esempio
(attenzione! codice non compilato!):
template<class T> class SecurVect {
    private:
        T* root;
        int size;
    public:
        SecurVect(int a) : root(0), size(a) {
            if(size < 1) exit(0);
            root =  new T[size];
        };
        ~SecurVect() {
            delete []root;
        };
        T * RilasciaPuntatore() {
            return root;
        };
        void Rialloca(int a) {
            if(a < 1) exit(0);
            delete []root;
            root =  new T[a];
            size = a;
        };
        T& operator[](int index) {
            if(index < 0 || index >= size) exit(0);
            return root[index];
        };
};
Ciao,
Nicola

 (attenzione! codice non compilato!):
ti ringrazio per la pazienza, ma il problema non è nella
SecurVect::Rialloca(), dove le cose funzionano come tu dici, senza problemi,
bensì nella SecurMatrix::Rialloca() (che nel mio primo post segue la
definizione della SecurVect), nella riga contrassegnata da //errore.
Suppongo di utilizzare la class SecurVect che hai definito tu:
template <class T> class SecurMatrix{
private:
        SecurVect<T>* root;
        int size;
public:
        SecurMatrix(int a, int b): root(0), size(a){
                if(a < 1){
                        exit(0);
                        }
                root = new SecurVect<T>[a](b);// errore
                size = a;
                };
[.....]
SecurMatrix::Rialloca(int a, int b){
                if(a < 1){
                        exit(0);
                        }
                delete []root;
                root = new SecurVect<T>[a](b); // errore
                size = a;
                };
};
Le righe contrassegnate da //errore in realtà non sono lecite (le ho scritte
così, per farmi capire, ben consapevole che non compileranno mai), poichè
non posso passare al costruttore di una classe argomenti attraverso
l'operatore new. E così non ho modo di riallocare gli oggetti. Mi chiedevo
se esistono dei trucchetti per fare comunque quello che io voglio.
Tutto qui (che non è poco, mi rendo conto)
ciao e grazie di nuovo.
Claves

Devi studiarti come funziona <vector>... :-)
Ciao,
Nicola

 Devi studiarti come funziona <vector>... :-)
già, me l'hanno suggerito anche su borland.public.cppbuilder.language.
Adesso il problema consisiterebbe nel passare alle dimensioni superiori. Ho
provato una sintassi del tipo:
//--- beg -----------------------------------
#include <vector>
using namespace std;
int main(int argc, char* argv[])
{
vector<char> alpha(100);
vector<vector<char> > beta(100);
        return 0;
}
//---- end --------------------------------
e compila, ma non ho capito come indicare la dimensione del vector più
"interno".
Se vi resta ancora un grammo di pazienza....
Grazie in anticipo.
Claves do Amaral
claves.d...@netbusiness.it

 C'č qualcuno in grado di darmi una mano, per favore?


 utile
ti ringrazio per l'appoggio. Quello che stavo cercando era un modo per
forzare il compilatore ad accettare anche paramteri non costanti, ma ho
capito che non è possibile. Speravo in qualche trucchetto che servisse ad
aggirare la limitazione, ma non è una cosa facilissima.
ciao
Claves

 "interno".
#include <vector>
typedef vector<vector<char> >   vvchar;
int main(int argc, char* argv[])
{
        vvchar  vv;
        // 100 x 100
        vv.resize(100);
        for( vvchar::iterator i=vv.begin( ) ; i != vv.end( ) ; i++
                i->resize(100);
}

 [...]
Per come è implementato non lo chiamerei SecurVect....
Saluti   Manlio Perillo