Specializzazione di 'modello <class _Tp> struct std :: less' in diversi namespace

Question

Sto specializzando il 'less' (predicato) per un tipo di dati.

Il codice simile a questo:

template<> 
struct std::less<DateTimeKey> 
{ 
    bool operator()(const DateTimeKey& k1, const DateTimeKey& k2) const 
    { 
     // Some code ... 
    } 
} 

Quando si compila (g ++ 4.4.1 su Ubuntu 9.10), ottengo l'errore:

specializzazione di 'template struct std :: meno' in diversi namespace

ho fatto qualche ricerca e ha scoperto che c'era una 'soluzione' che ha coinvolto avvolgendo la specializzazione in un namespace std - vale a dire cambiare il codice a:

namespace std { 
template<> 
struct less<DateTimeKey> 
{ 
    bool operator()(const DateTimeKey& k1, const DateTimeKey& k2) const 
    { 
     // Some code ... 
    } 
} 
} 

che, in effetti, spegne il compilatore. Tuttavia, quella soluzione era da un post di 5 anni (dal 'grande' Victor Bazarof non meno [punk non intenzionale]). Questa soluzione è ancora la strada da percorrere, oppure esiste un modo migliore per risolverlo oppure la "vecchia maniera" è ancora valida?

Answer 1

Questo è ancora il modo per farlo. Sfortunatamente non è possibile dichiarare o definire funzioni all'interno di uno spazio dei nomi come si farebbe con una classe: è necessario racchiuderle in un blocco namespace.

Answer 2

Il meno funtore non deve essere in std namespace. So

struct A 
{ 
    A(int _v=0):v(_v){} 
    int v; 
}; 


template<> struct less<A> 
{ 
    bool operator()(const A& k1, const A& k2) const 
    { 
     return k1.v < k2.v; 
    } 
}; 


std::map<A,int> m; 
m[A(1)] = 1; 
m[A(2)] = 2; 

Funziona come previsto. (Chiama il funtore che hai appena creato).

Immagino che tu lo sappia già, ma puoi semplicemente scrivere il tuo operatore < (k1, k2), che è quello che cerca meno il functor predefinito.

bool operator<(const DateTimeKey & k1, const DateTimeKey & k2) 
{ 
//your code... 
} 

Answer 3

Se è necessario specializzare un algoritmo standard, è possibile farlo nello spazio dei nomi std. È l'unica cosa che ti è permesso fare all'interno di quel namespace secondo lo standard.

[lib.reserved.names]/1

It is undefined for a C++ program to add declarations or definitions to namespace std or namespaces within namespace std unless otherwise specified. A program may add template specializations for any standard library template to namespace std. Such a specialization (complete or partial) of a standard library template results in undefined behavior unless the declaration depends on a user-defined name of external linkage and unless the specialization meets the standard library requirements for the original template

Ora, la domanda è se si vuole realmente specializzarsi std::less. Si noti che std::less chiamerà l'operatore di confronto definito per il proprio tipo, quindi è possibile fornire tale operazione anziché specializzare il modello.

Il problema con la specializzazione std::less per il tipo specifico è che causerà confusione se si fornisce un'operazione diversa da quella eseguita da operator< per il proprio tipo. Se eseguono la stessa operazione, lascia la definizione predefinita std::less senza specializzazione.

Se non si desidera fornire l'operatore di confronto, ma si desidera comunque utilizzare il tipo in contenitori associativi o con algoritmi che richiedono un comparatore, è possibile fornire un funtore di confronto esterno con un altro nome che non confonderà altri lettori (e te stesso da qualche parte nel futuro).

Answer 4

Perché lo stai facendo?

std::less esiste soltanto per due scopi:

1. per dare un nome all'operatore <, permettendogli di essere passato come functor
2. consentire agli confrontando due puntatori che non sono nello stesso array (che è tecnicamente illegale se fatto con puntatori grezzi)

Non c'è motivo per un utente di sovraccaricarlo - sovraccaricare operator< o utilizzare una funzione di confronto personalizzata.

Ci sono algoritmi std che possono essere sensibilmente specializzati - std::swap è un buon esempio - e per farlo è necessario dichiarare la specializzazione all'interno dello spazio dei nomi std.