Appeler un non-const fonction de membre à partir d'une fonction membre const

Il est possible:

const int& First() const 
{ 
    return const_cast<Foo*>(this)->Second(); 
}

int& Second() { return m_bar; }

Je ne recommanderais pas cela; c'est moche et dangereux (toute utilisation de const_cast est dangereux).

Il est préférable de déplacer autant de fonctionnalités courantes que vous pouvez dans des fonctions d'assistance, puis avoir votre const et non const fonctions de membres de chacun de faire aussi peu de travail que nécessaire.

Dans le cas d'un simple accesseur de ce genre, il est tout aussi facile à return m_bar; à la fois des fonctions qu'il est d'appeler une fonction de l'autre.

La restriction de const méthodes membres sont venus de la compilation. Si vous pouvez tromper le compilateur, alors oui.

class CFoo
{ 
public:
    CFoo() {m_Foo = this;}
    void tee();

    void bar() const 
    { 
        m_Foo->m_val++;  //fine 
        m_Foo->tee();    //fine
    }
private:
   CFoo * m_Foo;
   int    m_Val;  

};

Ce fait abolit le but de const fonction de membre, il est donc préférable de ne pas le faire lors de la conception d'une nouvelle classe. C'est pas mal de savoir qu'il y a un moyen de le faire,en particulier, il peut être utilisé comme un travail autour de ces vieux de la classe qui n'a pas été bien conçu sur le concept de fonction membre const.

les itérateurs sont similaires dans le présent et de faire une étude intéressante.

const itérateurs sont souvent la base pour le "non const' itérateurs, et vous trouverez souvent const_cast<>() ou C style jette utilisé pour rejeter const de la classe de base avec les accesseurs de l'enfant.

Edit:
Commentaire

J'ai un zip itérateur où la const on hérite de la non-const

Ce serait généralement le mauvais héritage de la structure (si votre de dire ce que je pense que vous êtes), la raison étant que les enfants ne devraient pas être moins restrictives que les parents.

disons que vous avez eu un algorithme de prendre votre zip itérateur, serait-il approprié de passer un const itérateur pour un non const ?

si vous aviez un const conteneur, ne pouvait demander pour un const itérateur, mais alors la const itérateur est dérivé à partir d'un itérateur, alors il suffit d'utiliser les fonctionnalités du parent non const accès.

Voici un rapide aperçu de suggestions de l'héritage à la suite de la traditionnelle modèle stl

class ConstIterator: 
    public std::_Bidit< myType, int, const myType *, const mType & >
{
  reference operator*() const { return m_p; }
}

class Iterator : public ConstIterator 
{
  typedef ConstIterator _Mybase;
  //overide the types provided by ConstIterator
  typedef myType * pointer;
  typedef myType & reference;

  reference operator*() const
  { 
    return ((reference)**(_Mybase *)this);
  }
}

typedef std::reverse_iterator<ConstIterator> ConstReverseIterator;
typedef std::reverse_iterator<Iterator> ReverseIterator;