Newsgroup: it.comp.lang.c++
Titolo: C2667: '_unique' : none of 2 overload have a best conversion

Secondo voi cosa non va?
namespace mylib
{
template <typename T>
class list
{
public:
......
 template <typename T, typename Is_greater> friend void _sort(list<T>& l,
Is_greater pred);
 template <typename T, typename Is_equal> friend void _unique(list<T>& l,
Is_equal pred);
protected:
......
public:
......
 template <typename Is_greater> void sort(Is_greater pred)  {_sort<T>(*this,
pred);}
 template <typename Is_equal> void unique(Is_equal pred)
{_unique<T>(*this, pred);}
......
}; // Fine classe
template <typename T, typename Is_greater> void _sort(list<T>& l, Is_greater
pred)
{ 
.......
}
template <typename T, typename Is_equal> void _unique(list<T>& l, Is_equal pred)
{ 
.......
}
} // fine namespace
questi gli errori:
error C2667: '_sort' : none of 2 overload have a best conversion
error C2668: '_sort' : ambiguous call to overloaded function
error C2667: '_unique' : none of 2 overload have a best conversion
error C2668: '_unique' : ambiguous call to overloaded function
 
Per quale motivo lui vede due _sort e due _unique mentre io vedo una dichiarazione e una definizione della stessa funzione sia per _sort che per _unique?
Notare che l'identificatore _sort non compare da nessuna altra parte.


Prova cosě:
 template <typename T>  class list;  // fwd decl
 template < typename T, typename Is_equal >
 void _unique( list<T>& l, Is_equal pred); //fwd decl
template <typename T>
class list
{
 public:
  template < typename Is_equal>
    friend  void _unique( list<T>& l, Is_equal pred);
 protected:
 public:
  template <typename Is_equal> void unique(Is_equal pred)
    {
        _unique< T, Is_equal >( *this, pred );
    }
 }; // Fine classe
 template <typename T, typename Is_equal>
 void _unique( list<T>& l, Is_equal pred)
 { // ...
 }
Se non funziona con le mie modifiche, puoi sempre implementare _unique come
membro di un'altra classe:
 template <typename T>  class list;  // fwd decl
 template < typename T, typename Is_equal >
 class unique_impl
 { public:
    void operator()(list<T>& l, Is_equal pred);
  };
 template <typename T>
 class list
 {
  public:
  template < typename Is_equal>
    friend  class unique_impl<T,Is_equal>;
  public:
  template <typename Is_equal>
   void unique(Is_equal pred)
    {   unique_impl<T,Is_equal> func;
        func(*this, pred);
    }
  }; // Fine classe
 template < typename T, typename Is_equal >
  void unique_impl<T,Is_equal>::operator()(list<T>& l, Is_equal pred)
  { //...
  }
Max

 Secondo voi cosa non va?
Un esempietto compilabile? Sarebbe pių facile capire l'esatta natura del
problema.
EMG
--
EMAG Software Homepage:     
http://www.emagsoftware.it
The EMG's ZX-Spectrum Page: 
http://www.emagsoftware.it/spectrum
The Best of Spectrum Games: 
http://www.emagsoftware.it/tbosg

  void _unique( list<T>& l, Is_equal pred); file://fwd decl

Non va lo stesso, avevo provato quel layout prima di postare. Ho risolto
modificando il codice in modo che non sia necessario che le due funzioni
_sort e _unique siano friend della classe. Una volta eliminata la
dichiarazione di friend il programma partiva e funzionava. Sembra che quella
dichiarazione friend dentro alla classe non si riferisca alla stessa
definizione di funzione subito fuori dalla classe, ma che si riferisca ad
altre funzioni non definite.