Ich versuche, ein Python zu wickelnPyObject* in einem (nObject Klasse. In Python ist alles einPyObject*. Eine Liste ist einPyObject*, und jedes Element in der Liste ist selbst einPyObject*. Das könnte sogar eine andere Liste sein. etc

Ich versuche zu erlaubenfooList[42] = barObj -Stilsyntax mit Hilfe eines Proxy-Musters Hie).

Nun, dass ich das arbeiten habe, möchte ich es so erweitern, dassfooList[42] kann als @ verwendet werdObject. Konkret möchte ich damit umgehen können ...

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

Object hat viele Methoden, und derzeitfooList[42].myObjMethod() wird zuerst auflösenfooList[42] in einProxy Instanz, sagtmpProxy und dann versuchetmpProxy.myObjMethod().

Dies bedeutet, ich müsste

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

d.h. jedes von @ manuell weiterleitObject 's Methoden durchProxy, das ist hässlich.

Ich kann keine perfekte Lösung sehen (siehe die oben verlinkte Antwort), aber ich würde gerne Folgendes verwenden:

fooList[42]->myObjMethod()

... als Kompromiss, da ->könne überladen sein (im Gegensatz zu. was nicht geht).

Ich kann jedoch keine Dokumentation zum Überladen findenoperator->.

Meine beste Vermutung ist, dass es einen Zeiger auf ein Objekt zurückgeben muss (sagen SiepObj) und C ++ ruft @ apObj->whatever.

Below ist mein Implementierungsversuch. Allerdings stoße ich auf ein 'Adresse eines temporären Objekts vom Typ Objekt übernehmen' Warnung

Ich habe in meinemObject class:

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

HINWEIS, dass 'const Object &' in @ läu 'Adresse eines temporären Objekts vom Typ Objekt übernehmen' Warnung

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
};

Die Idee ist, @ zu ermöglichmyList[5]->someMemberObj = ... Stilsyntax.

myList[5] wird als @ aufgelöProxy Instanz, die ein @ umhülObject (das sechste Element vonmyList). Nennen wir esmyItem.

Jetzt will ichsomeProxy->fooFunc() odersomeProxy->fooProperty, um @ aufzurufmyItem.fooFunc() odermyItem.fooProperty beziehungsweise

Ich laufe in ein 'Adresse eines temporären Objekts vom Typ Objekt übernehmen' Warnung