ich frage mich gerade, warum folgende Konstruktion bei meinem Compiler nicht funktioniert:

template<typename T>
const T* make_const( T* ptr )
{
   return const_cast<T*>( ptr );
}

template<typename T>
T* make_non_const( T* const ptr )
{
   return const_cast<T*>( ptr );
}

struct R
{
};

struct C
{
   R* find_r()
   {
      return NULL;
   }

   const R* find_r() const
   {
      return make_const( make_non_const( this )->find_r() ); 
   }
};

int main()
{
   const C theC;
   cont R* theC.find_r();
}

Der Plan ist, dass die const und non-const Methoden nur den Code der non-const Methode verwenden, indem der const-Aufruf zunächst in einen non-const this-Zeiger castet, dann die non-const Methode aufruft und das Ergbnis auf const castet. Aber bei meinem Compiler wird die non-const Methode nie aufgerufen, sondern immer wieder die const-Methode, bis das Programm in einen Stacküberlauf läuft.

Edit:
Mit

template<typename T>
T* make_non_const( const T* const ptr )
{
   return const_cast<T*>( ptr );
}

geht´s...

Ich bin davon ausgegangen, dass ein non-const Zeiger auf ein const Objekt gereicht hätte.

Der Typ des Parameters ist top-level const . Der Pointee-Typ des Zeigers ist im Rückgabetyp derselbe.

Richtig ist

template<typename T> 
T* make_non_const( T const* ptr ) 
{ 
   return const_cast<T*>( ptr ); 
}

Es ist gleichermaßen richtig, wie du bereits selbst festgestellt hast, das const nach vorne zu packen:

template<typename T> 
T* make_non_const( const T* ptr ) 
{ 
   return const_cast<T*>( ptr ); 
}

Das const nach dem Asterisk ist jedoch in jedem Fall überflüssig.

Der Plan ist, dass die const und non-const Methoden nur den Code der non-const Methode verwenden,

Das ist allerdings genau verkehrt herum. Wenn das Objekt, mit dem gearbeitet wird, tatsächlich const ist, und die non-const-Funktion tatsächlich Veränderungen durchführt, resultiert undefiniertes Verhalten.