Digamos que você tenha uma aula

    class C 
    {
      int * i;

      public:

         C(int * v):i(v) {};

         void method() const;  //this method does not change i
         void method();        //this method changes i
    }

Agora você pode querer definir uma instância const desta classe

    const int * k = whatever;
    const C c1(k); //this will fail

mas isso irá falhar por causa do construtor C non-const int C's (int * v)

então você define um construtor const int

    C(const int * v):i(v) {}; //this will fail also

Mas isso também falhará, já que o membro de C "int * i" não é const.

O que fazer nesses casos? Use mutável? Casting Prepare versão const de classe?

Editar: Após a discussão com Pavel (abaixo) eu investiguei um pouco este problema. Para mim, o que o C ++ faz não está correto. O destino do ponteiro deve ser um tipo estrito, o que significa que você não poderia, por exemplo, fazer o seguinte:

int i;
const int * ptr;
ptr = & i;

Nesse caso, a gramática da linguagem trataconst como uma promessa de não mudar o alvo do ponteiro. além do que, além do maisint * const ptr é uma promessa de não alterar o próprio valor do ponteiro. Assim você tem dois lugares onde const pode ser aplicado. Então você pode querer que sua classe modele um ponteiro (porque não). E aqui as coisas estão caindo em pedaços. A gramática C ++ fornece métodos const que são capazes de prometer não alterar os valores do próprio campo, mas não há nenhuma gramática que indique que seu método não alterará os alvos de seus ponteiros em classe.

Uma solução alternativa é definir duas classesconst_C eC por exemplo. Não é uma estrada real no entanto. Com modelos, suas especializações parciais é difícil não ficar preso em uma bagunça. Também todas as possíveis variações de argumentos comoconst const_C & arg, const C & arg, const_C & arg, C & arg não parece bonito. Eu realmente não sei o que fazer. Use classes separadas ou const_casts, cada caminho parece estar errado.

Em ambos os casos, devo marcar métodos que não modificam o alvo do ponteiro como const? Ou apenas siga o caminho tradicional que o método const não altera o próprio estado do objeto (o método const não se importa com o alvo do ponteiro). Então, no meu caso, todos os métodos seriam const, porque a classe está modelando um ponteiro, assim o ponteiro em si éT * const. Mas claramente alguns deles modificam o alvo do ponteiro e outros não.