const_cast Frage



  • Hallo zusammen,

    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.


  • Mod

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

    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.


  • Mod

    DocShoe schrieb:

    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.


Log in to reply