Newsgroup: it.comp.lang.c++
Titolo: template e poliformismo [bcb]

salve,
allora quello che devo realizzare è questo  ho una finestra (gui) ,in questo
contesto ma lo stesso principio può essere utilizzato per diverse
applicazioni,
in cui ci sono dei campi edit, io devo poter validare il valore di questi
campi secondo regole stabilite da me ho provato una struttura di questo
tipo:
//base  interfaccia
class c_abValidator {
public:
        c_abValidator() {};
        ~c_abValidator() {};
        //template<typename type>
        //bool validate(type data) {};
        virtual enErrValidazione  validate(string data) =0;
        void setMaxDimension(long val) {dim = val;  }
        long getMaxDimension() { return dim;  }
private:
long dim;
};
class c_ValidatorNumeric: public c_abValidator {
public:
        c_ValidatorNumeric():c_abValidator() {
        }
        ~c_ValidatorNumeric() {
        }
        //template<typename type>
        //bool validate(type data) {
        enErrValidazione validate(string data) {
                if (data == "")
                        return value_null;
                //validazione di misura massima
                if (data.size() > getMaxDimension())
                        return size_invalid;
                //validazione di formato numerico
                try {
                        StrToInt64(data.begin());
                }
                catch(...) {
                        return format_invalid;
                }
        return no_error;
        }
};
purtroppo per molteplici motivi questa struttura non va bene , il tipo
passato in validate è string io vorrei poter avere tipi generici
ma purtroppo i virtual ed i  template non vanno daccordo come posso
risolvere ?

 risolvere ?
Una funzione membro templatica non puņ essere virtual. Punto e basta.
Quindi se ti serve virtuale elimini il fatto che sia templatica.
Per esempio puoi giocare sporco e gli passi gli argomenti come void* (ma
č abbastanza sporco, francamente).
Oppure riprogetti l'applicazione.
-- 
RiK0
Non credo negli schemi non vincenti.

 Una funzione membro templatica non può essere virtual. Punto e basta.
[...]
E il motivo dovrebbe essere abbastanza chiaro...
Immaginiamo, per assurdo, di poter avere un'interfaccia del genere:
== base.h
class Base {
 public:
  template<typename T>
  virtual void f(T t) = 0;
};
==
Come potremmo usare una tale interfaccia ?
== cliente.cc
#include "base.h"
#include "factory.h"
// Usiamo una factory per ottenere un istanza
// di qualche classe concreta che implementa Base
Base* b = Factory::CreateConcreteClass();
// a questo punto il compilatore (e in teoria anche 
// il programmatore) non e' in grado di sapere quale 
// classe concreta e' stata istanziata,
// ma conosce soltanto l'interfaccia
class Ciccio {
 // questa e' una classe qualunque, che definiamo
 // qui. Chi ha creato l'oggetto concreto puntato
 // da b non conosce assolutamente questa classe. 
};
Ciccio c; 
// E' impossibile a questo punto ottenere una versione
// di f() che funzioni per "Ciccio" !
b->f( c );  (???)
Ma se Base diventa una classe template, tutto cambia:
== base.h
template<typename T>
class Base {
 public:
  virtual f(T t) = 0;
};
==
== cliente.cc
#include "base.h"
#include "factory.h"
class Ciccio { /* quella di prima */ };
// chiediamo alla factory un'implementazione di Base<Ciccio> 
Base<Ciccio> *b = Factory::CreateConcreteClass<Ciccio>();
Ciccio c;
b->f(c); // tutto liscio 
Tornando all' OP, non sono pero' sicuro che tu abbia veramente bisogno
di una classe template. O almeno non mi sembra che tu possa definire
in maniera generica un metodo validate(T) una volta per tutti i tipi.
-- Fabio

> Una funzione membro templatica non può essere virtual. Punto e basta.
[cut]
questo lo so e capisco anche il motivo quello mi chiedevo era come risolvere
anche riprogettando...
(sono ot ? )
ciao

 (sono ot ? )
IMHO no. Il fatto che la faccenda riguarda la GUI è solo un caso. È il
contesto nel quale si è presentato.


Secondo me ti conviene definire le classi derivate come
specializzazioni di un template sul tipo del valore da gestire. Il
componente lo passi al costruttore della sotto-classe di validazione in
modo che sappia come prendersi il valore da sola. La funzione che
controlla il valore la specializzi in modo opportuno per ogni tipo di
valore gestito. Cosi' facendo la funzione membro validate() non ha
bisogno ne di argomenti ne di valore di ritorno (oppure un booleano per
indicare se il valore e' valido) e puo' tornare ad essere virtuale
pura.
Qualcosa come:
class Validator {
public:
virtual ~Validator() {}
virtual bool validate() = 0;
};
template <typename ValueT> class ValidatorImpl {
public:
ValidatorImpl(SomeComponent * c) : comp(c) {}
bool validate() { return checkValue(getValue())); }
private:
std::string getValue();
bool checkValue(const std::string & v);
};
template <typename ValueT>
std::string ValidatorImpl<ValueT>::getValue() {
/* da implementare */
}
template <> bool ValidatorImpl<int>::getValue() {
/* da implementare */
}
[Scritto di getto e non compilato]
Ciao,
Nicola


sarebbe bello ma cosě lego la classe ad il componente in questione (ed uno 
degli obittivi che mi era prefissato)
se per cosa vorrei riusare questo sistema con un'altr framework opppure con 
un'altro tipo di logica non andrebbe bene. 

 template...
perchè con l'attuale struttura il tipo da validare è ristretto a string si 
posso fare delle conversioni before
validazione dal tipo originario a string ma sarebbe stato bello se potevo 
passare un tipo qualsiasi

Se il tuo framework di gestione ha la grana giusta non dovrebbe essere
un gran problema. Dopotutto per ogni componente dello stesso tipo devi
riscrivere il codice per accedervi. Metti di decidere ad un certo punto
di svuotare un campo con un valore scorretto, o di scriverlo a colori
invertiti. Meglio incapsulare tutto cio' in una classe che sa gestire
quel tipo di componente, che riscriverlo ogni volta, no?
Ciao,
Nicola

<Nicola....@ObjectWay.it> ha scritto nel messaggio 
news:1105092158.1...@z14g2000cwz.googlegroups.com...

a,b,c ecc derivano tutte da una stessa interfaccia base ...
non ce modo di poterle usare tutte cosě mi schiate ?

 ha scritto nel messaggio 
news:I1uDd.649110$35.26...@news4.tin.it...

hoo sbagliato dove indirizzare l'ultimo post 

 string ma sarebbe stato bello se potevo passare un tipo qualsiasi
Che tanto non avresti avuto modo di validare... come fai sapere se un
tipo arbitrario č corretto?
Fallo per le stringhe. Se poi hai bisogno di altro, overloadi... tanto
non credo che ti arriveranno sti gran tipi da una GUI... al piů numeri.
