Tengo una implementación simple de puntero inteligente que se muestra en el fragmento de código 1 a continuación. Y una clase de prueba ficticia llamada Dummy en el segundo fragmento. El fragmento de código 3 muestra cómo podemos utilizar este simple puntero inteligente para acceder a la función foo ().

Mi pregunta es sobre la forma en que invocamos la función foo () en la clase Dummy utilizando el operador ->. -> operador ya devuelve un puntero al puntero en bruto. Entonces, creo que, para que podamos invocar la función foo (), necesitamos realizar una segunda operación -> en el puntero en bruto devuelto. Sin embargo, muchos recursos dicen que un solo uso del operador -> es suficiente simplemente.

En pocas palabras, creo que la llamada correcta debería ser como la siguiente: (dummy ->) -> foo ();

Sin embargo, la llamada como esta dummy-> foo () funciona bien. ¿Puede alguien explicarme por qué (dummy ->) -> foo () es incorrecto? Tal vez, tengo un malentendido conceptual pero me gustaría saber el concepto correcto.

CODIGO SNIPPET 1 (Clase INTELIGENTE DEL PUNTERO)

template <typename T>
class SmartPointer
{
 private:
    T* mRawPointer;

 public:
    SmartPointer(T* thePointer) : mRawPointer(thePointer) {}
    ~SmartPointer() { delete mRawPointer;}

    T& operator* () const { return *mRawPointer; }

    T* operator-> () const { return mRawPointer; }

};

CODIGO SNIPPET 2 (Clase Dummy)

class Dummy
{
 public:
   foo() {......}
};

CÓDIGO SNIPPET 3 (ALTERNATIVAS DE INVOCATCIÓN EN PREGUNTA)

SmartPointer<Dummy> dummy(new Dummy());

(dummy->)->func(); 
//I think the above is correct cause we need to make a second dereference on the 
//returned raw pointer
//OR
dummy->func();