es.davy.ai

Preguntas y respuestas de programación confiables

¿Tienes una pregunta?

Si tienes alguna pregunta, puedes hacerla a continuación o ingresar lo que estás buscando.

Sobrecargar el operador de desreferencia en Cython.

14 Jul, 2023 Programación

En el código anterior, recibo un objeto de tipo PPho y quiero recuperar el objeto Pho dentro del puntero compartido. ¿Cómo puedo hacer eso? Intenté acceder directamente al shared_ptr, pero es privado. Intenté desreferenciarlo dos veces. Luego intenté sobrecargar el operador de desreferenciación, pero no tuve éxito (el error también se muestra a continuación).

Código en C++ (hpp):

class PPho {
  private:
    std::shared_ptr<pho> PhoPtr;
  public:
    Pho *operator->() const;
    PPho(const PPho &Other);
    PPho(const std::shared_ptr<pho> &Other);
    PPho(std::nullptr_t);
    PPho();
    PPho &operator=(const PPho &Other);
    PPho &operator=(const std::shared_ptr<pho> &Other);
    operator std::shared_ptr<pho>() const;
    operator std::weak_ptr<pho>() const;
    operator bool() const;
    /// Liberar el recurso apuntado y establecer Pointer como nullptr.
    void Reset();
}

class Pho {
    Pho();
}

Código de encabezado en Cython que estoy intentando usar (pxd):

cdef cppclass Pho:
    Pho()
    Pho(Pho &Other)

cdef cppclass PPho:
    PPho() except +
    shared_ptr[Pho] PhoPtr
    Pho *operator "*operator->()"

Código en Cython (pyx):

cdef class PyPPho:
    cdef PPho* device
    def __cinit__(self):
        self.device = NULL
    cdef assign_device(self, PPho& device_):
        self.device = &device_
    cdef get_pho(self):
        return deref(self.device).get()

Mensaje de error:

“`
cdef Get(self):
return deref(self.device).get()
^

<hr />

Ppho.pyx:43:33: El objeto de tipo 'PPho' no tiene el atributo 'get'
“`

Tags:  ,

Answer

  1. Avatar for davy.ai
    davy.ai

    Para recuperar el objeto Pho dentro del puntero compartido en la clase PPho, puedes usar el operador flecha (->) sobrecargado en la clase PPho para acceder al objeto Pho. Esto se puede hacer utilizando el siguiente código:

    Pho* operator->() const {
    return PhoPtr.get();
}

    Luego, puedes acceder al objeto Pho utilizando el operador flecha en el objeto PPho:

    PPho mi_objeto_ppho;
Pho* mi_objeto_pho = mi_objeto_ppho->get();

    Si obtienes un error que indica que shared_ptr es privado cuando intentas accederlo directamente, puedes hacer una declaración de amistad para la clase PPho en la clase Pho para permitir el acceso al shared_ptr:

    class Pho {
    friend class PPho;
    /* resto de la definición de la clase Pho */
};

    También puedes sobrecargar el operador de desreferencia (*) en la clase PPho para acceder directamente al objeto Pho desde el puntero compartido. Para hacer esto, puedes utilizar el siguiente código:

    Pho& operator*() const {
    return *PhoPtr;
}

    Esto te permite acceder al objeto Pho desreferenciando el objeto PPho:

    PPho mi_objeto_ppho;
Pho mi_objeto_pho = *mi_objeto_ppho;

    Sin embargo, es importante tener en cuenta que sobrecargar el operador de desreferencia puede no funcionar si shared_ptr es nulo. En este caso, debes utilizar el operador flecha en su lugar para acceder al objeto Pho.

Comments are closed.