Const C ++ DRY Strategies

Per evitare duplicazioni costanti non banali di C ++, ci sono casi in cui const_cast potrebbe funzionare, ma una funzione const privata che restituisce non-const non lo sarebbe?

Nell'articolo Effective C ++ di Scott Meyers, suggerisce che un const_cast combinato con un cast statico può essere un modo efficace e sicuro per evitare il codice duplicato, ad esempio

const void* Bar::bar(int i) const
{
  ...
  return variableResultingFromNonTrivialDotDotDotCode;
}
void* Bar::bar(int i)
{
  return const_cast<void*>(static_cast<const Bar*>(this)->bar(i));
}

Meyers continua spiegando che avere la funzione const chiama la funzione non-const pericolosa.

Il codice sotto è un contro-esempio che mostra:

• contrariamente al suggerimento di Meyers, a volte il const_cast combinato con un cast statico è pericoloso
• a volte avere la funzione const chiama non-const è meno pericoloso
• a volte in entrambi i modi l'uso di un const_cast nasconde errori di compilazione potenzialmente utili
• evitare un const_cast e avere un membro privato const aggiuntivo che restituisce un non-const è un'altra opzione

Le strategie const_cast di evitare la duplicazione del codice sono considerate buone prassi? Preferiresti invece la strategia del metodo privato? Ci sono casi in cui const_cast funzionerebbe, ma non sarebbe un metodo privato? Ci sono altre opzioni (oltre alla duplicazione)?

La mia preoccupazione per le strategie const_cast è che anche se il codice è corretto quando scritto, in seguito durante la manutenzione il codice potrebbe diventare errato e il const_cast nasconderebbe un utile errore del compilatore. Sembra che una funzione privata comune sia generalmente più sicura.

class Foo
{
  public:
    Foo(const LongLived& constLongLived, LongLived& mutableLongLived)
    : mConstLongLived(constLongLived), mMutableLongLived(mutableLongLived)
    {}

    // case A: we shouldn't ever be allowed to return a non-const reference to something we only have a const reference to

    // const_cast prevents a useful compiler error
    const LongLived& GetA1() const { return mConstLongLived; }
    LongLived& GetA1()
    {
      return const_cast<LongLived&>( static_cast<const Foo*>(this)->GetA1() );
    }

    /* gives useful compiler error
    LongLived& GetA2()
    {
      return mConstLongLived; // error: invalid initialization of reference of type 'LongLived&' from expression of type 'const LongLived'
    }
    const LongLived& GetA2() const { return const_cast<Foo*>(this)->GetA2(); }
    */

    // case B: imagine we are using the convention that const means thread-safe, and we would prefer to re-calculate than lock the cache, then GetB0 might be correct:

    int GetB0(int i) { return mCache.Nth(i); }
    int GetB0(int i) const { return Fibonachi().Nth(i); }

    /* gives useful compiler error
    int GetB1(int i) const { return mCache.Nth(i); } // error: passing 'const Fibonachi' as 'this' argument of 'int Fibonachi::Nth(int)' discards qualifiers
    int GetB1(int i)
    {
      return static_cast<const Foo*>(this)->GetB1(i);
    }*/

    // const_cast prevents a useful compiler error
    int GetB2(int i) { return mCache.Nth(i); }
    int GetB2(int i) const { return const_cast<Foo*>(this)->GetB2(i); }

    // case C: calling a private const member that returns non-const seems like generally the way to go

    LongLived& GetC1() { return GetC1Private(); }
    const LongLived& GetC1() const { return GetC1Private(); }

  private:
    LongLived& GetC1Private() const { /* pretend a bunch of lines of code instead of just returning a single variable*/ return mMutableLongLived; }

    const LongLived& mConstLongLived;
    LongLived& mMutableLongLived;
    Fibonachi mCache;
};

class Fibonachi
{ 
    public:
      Fibonachi()
      {
        mCache.push_back(0);
        mCache.push_back(1);
      }

      int Nth(int n) 
      {
        for (int i=mCache.size(); i <= n; ++i)
        {
            mCache.push_back(mCache[i-1] + mCache[i-2]);
        }
        return mCache[n];
      }

      int Nth(int n) const
      {
          return n < mCache.size() ? mCache[n] : -1;
      }
    private:
      std::vector<int> mCache;
};

class LongLived {};