Newsgroup: it.comp.programmare.win32
Titolo: Derivare una classe da un template

Si puo` fare l'operazione al subj? Faccio un esempio: se io voglio
derivare da CArray una classe che faccia delle operazioni aggiuntive (ad
esempio implementi l'operatore =) lo posso fare?
Io avevo fatto una cosa del genere:
template<class TYPE, class ARG_TYPE> class CCopyArray: public
CArray<TYPE,ARG_TYPE>
{
    public:
        void operator=( CCopyArray<TYPE,ARG_TYPE>& src);
};
template<class TYPE, class ARG_TYPE>
    void CCopyArray<TYPE,ARG_TYPE>::operator=(
    CCopyArray<TYPE,ARG_TYPE>& src)
{
    RemoveAll();
    int a, n = src.GetSize();
    for( a=0; a<n; a++)
        Add( src.GetAt(a));
}
Si compila correttamente, ma poi mi da` degli unresolved external in
fase di linking come se la definizione dell'operatore = fosse diversa
dalla dichiarazione.
Aiuto, sono intrappolato fra i virtuosismi del C++! :)
-- 
Lorenzo

 Aiuto, sono intrappolato fra i virtuosismi del C++! :)
Bé, posso riportare un caso funzionante (quello con righe numerate)
così che tu possa verificare se il tuo compilatore accetta questi 
funambolismi. Preso dal manuale di Sharam Hekmat "C++ Programming"
---------------
               Derived Class Templates
A class template (or its instantiation) can serve as the base of a
derived class:
    template <class Type>
    class SmartList : public List<Type>; // template base
    class Primes : protected List<int>; // instantiated base
A template base class, such as List, should always be accompanied with
its
parameter list (or arguments if instantiated). The following is
therefore invalid:
    template <class Type>
    class SmartList : public List; // illegal! <Type> missing
It would be equally incorrect to attempt to derive a nontemplate class
from a
(non-instantiated) template class:
    class SmartList : public List<Type>; // illegal! template expected
It is, however, perfectly acceptable for a normal class to serve as the
base of a
derived template class:
    class X;
    template <class Type> class Y : X; // ok
As an example of a derived class template, consider deriving
a Set class from List.
Given that a set consists of unique elements only 
(i.e., no repetitions), all we need to do is override
the Insert member function to ensure this:
1 template <class Type>
2 class Set : public List<Type> {
3 public:
4 virtual void Insert (const Type &val)
5 {if (!Member(val)) List<Type>::Insert(val);}
6 };
-----------------------
Una stupida piccola raccomandazione:
fai attenzione ai puntatori o reference della classe base:
l'ereditarietà non comporta che puntino allo stesso oggetto.
Spero di esserti stato di aiuto.
JJ
-- 
Posted via Mailgate.ORG Server - 
http://www.Mailgate.ORG

 Spero di esserti stato di aiuto.
Si`, grazie mille!
-- 
Lorenzo

 dentro la dichiarazione della classe.
Quanto accade non è colpa di Visual C++ ma, semplicemente, non è possibile
effettuare la compilazione separata dei template. Ti invito a chiedere su
it.comp.lang.c++ per saperne di più.
--
  Jerle Shannara
Per rispondere in email sostituisci JERLEANTISPAM con inwind
homepage 
http://utenti.lycos.it/jerleshannara

 effettuare la compilazione separata dei template.
In effetti bastava pensarci... come puo` il compilatore sapere a quale
tipo associerai il template? :)
-- 
Lorenzo

Con i template puoi sempre creare un .h e un .cpp, ma quando lo userai devi
includere il .cpp e non il . h.
Perchè inizialmente il template prende in giro il compilatore, nel senso
che, fa credere al compilatore che i tipi passati al template <class T>
siano già conosciuto, ma in realta questo viene risolto a "run-time", perciò
se includi il .h, il .cpp risulterebbe "vuoto",
e il linker nn riesce a trovare le funzione che nel tuo caso è l'operatore.
Forse nn sono stato chiaro, ma è difficile come concetto(almeno per me )
questa cosa l'ho trovata su un numero di "IoProgrammo" mi sembra
gennaio/febbraio...
ciao
JoGiò