const_cast nel modello. C'è un modificatore inconstante?

Question

Ho una classe template in questo modo:

template<T> 
class MyClass 
{ 
    T* data; 
} 

A volte, voglio usare la classe con un tipo costante T come segue:

MyClass<const MyObject> mci; 

ma voglio modificare i dati utilizzando const_cast<MyObject*>data (non è importante perché, ma MyClass è una classe di puntatore intelligente di conteggio di riferimento che conserva il conteggio dei riferimenti nei dati stessi. I dati non devono essere modificati ma il conteggio deve essere modificato dal puntatore intelligente.).

C'è un modo per rimuovere la costanza da T? Codice di fantasia:

const_cast<unconst T>(data) 

?

Answer 1

Il modo più semplice sarebbe quello di rendere mutabile il conteggio dei riferimenti.

Tuttavia, se siete interessati a come avrebbe funzionato con la const_cast, poi reimplementare di remove_const spinta dovrebbe essere abbastanza semplice:

template <class T> 
struct RemoveConst 
{ 
    typedef T type; 
}; 

template <class T> 
struct RemoveConst<const T> 
{ 
    typedef T type; 
}; 

const_cast<typename RemoveConst<T>::type*>(t)->inc(); 

Answer 2

Hai la risposta. const_cast funziona in entrambe le direzioni:

char* a; 
const char* b; 

a = const_cast<char*>(b); 
b = const_cast<const char*>(a); // not strictly necessarily, just here for illustration 

Per quanto riguarda il problema specifico, hai considerato la parola chiave mutabile? Permette di modificare una variabile membro all'interno di un metodo const.

class foo { 
    mutable int x; 
public: 
    inc_when_const() const { ++x; } 
    dec_when_const() const { --x; } 
}; 

Answer 3

Se è possibile utilizzare Boost, la libreria dei tipi Tratti fornisce la remove_const metafunction che lo fa.

Answer 4

Rende mutabile il conteggio dei riferimenti nella classe gestita dal puntatore intrusivo. Questo è del tutto ragionevole e riflette la "coerenza logica" in modo esatto - cioè, la modifica del conteggio dei riferimenti dell'oggetto non riflette alcun cambiamento nello stato dell'oggetto stesso. In altre parole, il conteggio dei riferimenti non è logicamente parte dell'oggetto - l'oggetto sembra essere un posto conveniente in cui archiviare questi dati semi-non correlati.

Answer 5

Ecco il mio C++ 11 unconst funzione template.

Se lo si utilizza, si stanno flirtando con undefined behavior. Sei stato avvertito.

// on Ubuntu (and probably others) compile and test with               
// g++ -std=c++11 test.c && ./a.out ; echo $?        

template < class T > T & unconst (T const & t) { 
    return const_cast < T & > (t) ; 
} 

// demonstration of use 

struct { 
    const int n = 4; 
} s; 

int main() { 
    unconst (s.n) = 5; 
    return s.n; 
}