Newsgroup: it.comp.lang.c++
Titolo: Problema con classe che eredita da classe template

Il codice che segue mi da' qualche problema:
///// HDC.hpp
#include <windows.h>
template<class _T> class _trivial_wrapper_t
{
 public:
  typedef _T _Type;
 
  _Type m_Value;
  // constructors
  inline _trivial_wrapper_t(void) {};
  inline _trivial_wrapper_t(_T _Value): m_Value(_Value) {};
  // operators
  inline _Type operator=(_Type _New){ m_Value = _New; return _New; }
  inline _Type * operator&(void) { return &m_Value; }
  // extractors
  inline operator _Type(void) { return m_Value; }
};
class _hdc_t: public _trivial_wrapper_t<HDC>
{
 public:
  // destructor
  inline ~_hdc_t(void) { if(m_Value) DeleteDC(m_Value); }
};
/////
Nella fattispecie, il seguente codice che usa la classe di cui sopra:
_hdc_t hdcCompatible = CreateCompatibleDC(hdcScreen);
causa questo errore:
[C++ Error] main.cpp(10): E2034 Cannot convert 'void *' to '_hdc_t'
che *non* si verifica se tutto il contenuto di _trivial_wrapper_t viene 
de-templatizzato e messo dentro _hdc_t (come era in origine). Mi par di 
capire che, per ragioni a me oscure, il costruttore con il parametro di 
inizializzazione venga ignorato. Già ho dovuto mettere quel typedef là, 
sempre per ragioni a me non del tutto chiare, ma ora non so proprio che 
fare. Idee?
-- 
  < 
http://www.reactos.com/
 >  Open source clone of Windows NT. Current
      Don't stand, REACT!      version 0.1.0. C, C++ and ASM developers
                               and beta testers are welcome!

[C++ Error] main.cpp(10): E2034 Cannot convert 'void *' to '_hdc_t'
guarda qui il perchè:
http://unboffable.hn.org/juliet.php
se ci pensi è buffo quello che ti è successo :)
ciao
 sbirish

Ho visto il tuo esempio su 
http://www.unboffable.hn.org/juliet.php
e ho qualche osservazione.
il costruttore di copia e l'operatore di assegnamento DEVONO avere
il parametro di ingresso come "const T&", quindi:
  TrivialWrapper(TType& value): value_(value) {};
diventa
  TrivialWrapper(const TType& value): value_(value) {};
e
  TType& operator=(TType& other)
diventa
  TType& operator=(const TType& other)
di conseguenza
TType& operator=(TType& other)
{
  TType temp(other);
  std::swap(value_,other);
  return value_;
}
diventa
TType& operator=(TType& other)
{
  TType temp(other);
  std::swap(value_,temp);
  return value_;
}
infatti std::swap ha chiaramente i parametri non "const"
Per il resto complimenti per la completezza dell'esempio
Ciao
Fabio

 il parametro di ingresso come "const T&", quindi:
Questo non è esatto. E' senz'altro buona norma dichiarare 'const'
l'argomento del copy-ctor, e nella stragrande maggioranza dei casi (come,
credo, in quello in questione) non vi è ragione di fare altrimenti, ma lo
Standard non lo impone (cfr. 12.1 [class.ctor]).
MM

 credo, in quello in questione) non vi č ragione di fare altrimenti, ma lo


verra' modificato dalla classe.
perfetta osservazione.. concordo anche sul _deve_ essere const..
mio errore.. 
sbirish

Fabio
ciao
 sbirish

 se ci pensi è buffo quello che ti è successo :)
non ho capito
comunque. Grazie dei suggerimenti, anche se alla fine è bastata la cosa 
più banale del mondo: un estrattore di _T&. A questo punto non so se ha 
ancora senso una classe base
