Estoy tratando de envolver un PythonPyObject* en unObject clase. En Python, todo es unPyObject*. Una lista es unPyObject*, y cada elemento de la lista es en sí mismo unPyObject*. Que incluso podría ser otra lista. etc.

Estoy tratando de permitirfooList[42] = barObj sintaxis de estilo mediante un patrón Proxy (aquí)

Ahora que tengo eso funcionando, quiero extenderlo para quefooList[42] se puede usar comoObject. Específicamente quiero poder manejar ...

fooList[42].myObjMethod()
fooList[42].myObjMember = ...

Object tiene muchos métodos y actualmentefooList[42].myObjMethod() se va a resolver primerofooList[42] en unaProxy ejemplo, digamostmpProxyy luego intentetmpProxy.myObjMethod().

Esto significa que tendría que hacer

void Proxy::myObjMethod(){ return wrapped_ob.myObjMethod(); }

es decir, retransmitir manualmente cada uno deObjectmétodos a través deProxy, lo cual es feo.

No puedo ver ninguna solución perfecta (ver la respuesta vinculada anteriormente), pero me encantaría usar:

fooList[42]->myObjMethod()

... como un compromiso, viendo como ->puede estar sobrecargado (en lugar de. que no puede).

Sin embargo, no puedo encontrar ninguna documentación para sobrecargaroperator->.

Mi mejor suposición es que debe devolver un puntero a algún objeto (digamospObj), y C ++ invocarápObj->whatever.

A continuación se muestra mi intento de implementación. Sin embargo, me encuentro con un'tomar la dirección de un objeto temporal de tipo Object' advertencia.

Tengo dentro de miObject clase:

const Object operator[] (const Object& key)     const { 
    return Object{ PyObject_GetItem( p, key.p ) }; 
}

NOTA que 'const Object &' se encuentra con'tomar la dirección de un objeto temporal de tipo Object' advertencia.

class Proxy {
private:
    const Object& container;
    const Object& key;

public:
    // at this moment we don't know whether it is 'c[k] = x' or 'x = c[k]'
    Proxy( const Object& c, const Object& k ) : container{c}, key{k}
    { }

    // Rvalue
    // e.g. cout << myList[5] hits 'const Object operator[]'
    operator Object() const {
        return container[key];
    }

    // Lvalue
    // e.g. (something = ) myList[5] = foo
    const Proxy&  operator= (const Object& rhs_ob) {
        PyObject_SetItem( container.p, key.p, rhs_ob.p );
        return *this; // allow daisy-chaining a = b = c etc, that's why we return const Object&
    }

    const Object* operator->() const { return &container[key]; }
    // ^ ERROR: taking the address of a temporary object of type Object
};

La idea es permitirmyList[5]->someMemberObj = ... sintaxis de estilo

myList[5] se resuelve como unProxy instancia, que está envolviendo unObject (el sexto elemento demyList) Vamos a llamarlomyItem.

Ahora quierosomeProxy->fooFunc() osomeProxy->fooProperty invocarmyItem.fooFunc() omyItem.fooProperty respectivamente.

Me encuentro con un'tomar la dirección de un objeto temporal de tipo Object' advertencia.