Magie von -> ?



  • Hi

    Ich meine mal gelesen zu haben, dass -> immer so weit wie möglich dereferenziert.

    Müsste folgendes dann nicht funktionieren:

    #include <iostream>
    
    class foo
    {
    public:
    	void bar()
    	{
    		std::cout << "foo::bar";
    	}
    };
    
    class PtrToFoo
    {
    	foo *m_f;
    
    public:
    	PtrToFoo( foo *f ) : m_f( f ){}
    
    	foo* operator->(){ return m_f; }
    };
    
    int main()
    {
    	foo f;
    
    	PtrToFoo *p = new PtrToFoo( &f );
    
    	p->bar(); //error C2039: 'bar': Ist kein Element von 'PtrToFoo'
    
    	delete p;
    
    	return 0;
    }
    

    Oder trügt mich nur meine Erinnerung bzw. sehe ich das falsch?

    gruß
    rean



  • Nur ein überladener operator-> dereferenziert weiter, wenn der zurückgegebene Typ ebenfalls einen solchen Operator bereitstellt. Sobald es sich um einen Zeiger handelt, wird nur noch dieser dereferenziert. Wäre nicht gut, wenn sich die Semantik bei eingebauten Typen ändern würde.



  • Aber Dein Objekt p soll wie ein Zeiger sein.
    Also

    int main()
    {
        foo f;
    
        PtrToFoo p( &f );
    
        p->bar();
    
        return 0;
    }
    

    Was Du gemacht hattest, was ein Zeiger auf ein Objekt, das wie ein Zeiger sein soll.



  • volkard schrieb:

    Aber Dein Objekt p soll wie ein Zeiger sein.
    Also

    int main()
    {
        foo f;
    
        PtrToFoo p( &f );
    
        p->bar();
    
        return 0;
    }
    

    Was Du gemacht hattest, was ein Zeiger auf ein Objekt, das wie ein Zeiger sein soll.

    Ja, das ist ein stark vereinfachtes Beispiel. In meinem konkreten Anwendungsfall brauche ich Pointer auf PtrToFoo um Polymorphie verwenden zu können.

    Danke für die Aufklärung.



  • Also dann

    int main()
    {
        foo f;
    
        PtrToFoo *p = new PtrToFoo( &f );
    
        (*p)->bar(); //error C2039: 'bar': Ist kein Element von 'PtrToFoo'
    
        delete p;
    
        return 0;
    }
    

Log in to reply