在 C++11 中实现递归代理模式

你的前提似乎有缺陷。根据定义，Proxy不是Object;如果是这样，那么你一开始就不会称它为Proxy。然后你可以在没有代理的情况下解决问题，就像std::map这样的标准数据类型解决问题一样：只需在必要时operator[]返回对新创建的Object的引用。

您正在寻找类似于 std::vector<bool> 的代理模式：operator[] 返回一个带有operator=和隐式转换为非代理Object的Proxy（适用于您真正想要使用该值而不是赋值的情况）。

class Object {
    struct Proxy {
        PyObject *container;
        PyObject *key;
        Proxy(PyObject *c, PyObject *k): container(c), key(k) {}
        Proxy& operator= (const Object& value) { 
            PyObject_SetItem(container, key, value.p); 
            return *this; 
        }
        operator Object() const {
            PyObject *p = PyObject_GetItem(container, key);
            if (p == nullptr) throw "proxy was not backed by a real object";
            return p;
        }
    };
    PyObject *p;
    Object(PyObject* p): p(p) {}
public:
    Object operator[] (const Object& key) const { 
        return PyObject_GetItem(p, key.p); 
    }
    Proxy operator[] (const Object& key) { return {p, key.p}; }
};

我最终解决了这个问题。

诀窍是简单地将类用作自己的代理。

因此，最初代理对象提供转换以区分左值和右值访问的地方，我只是将这些转换移回我的原始对象类：

    mutable bool m_resolve_me{false};
    PyObject* m_container{nullptr};
    PyObject* m_key{nullptr};
public:
    // Rvalue (e.g. x = ob[42];)
    const Object operator[] (const Object& key)  const { 
        return Object{ PyObject_GetItem( p, key.p ) }; 
    } 
    // Don't know yet
    Object operator[] (const Object& key) { 
        return Object{ *this, key }; 
    }
    // notice we set the m_resolve_me flag
    // as we don't yet know L/Rvalue-ness
    Object( const Object& c, const Object& k )
        : m_container{c.p}, m_key{k.p}, m_resolve_me{true}
    {
        // for all but lvalue access (ob[idx]=...), ob[idx] will be valid
        p = PyObject_GetItem( m_container, m_key ); 
        if( p == nullptr ) {
            // ... However in the case of lvalue access, 
            // PyObject_GetItem will set Python's error indicator
            // so we must flush that error, as it was expected!
            PyErr_Clear();
            p = charge(Py_None);
        }
        // ^ either way, p ends up charged
    }
public:
    // this will attempt to convert ANY rhs to Object, which takes advantage of ALL the above constructor overrides
    Object& operator=( const Object& rhs )
    {
        /*
            1) normal situation
            2) this object is m_resolve_me, and we are assigning 
                 a normal object to it
            3) this object is m_resolve_me, and we are assigning 
                 a m_resolve_me object to it
            4) this object is normal, and we are assigning a m_resolve_me object to it
            1) we need to charge p
            2) same
            3) same
            4) same
            The only important thing is: we have to be neutral to rhs.p
            That means we have to charge it, as we will be 
               subsequently neutralising it in the destructor
         */
        if( &rhs != this )
            *this = charge(rhs.p);
        return *this;
    }
    // (Always) assume charged pointer
    Object& operator=( PyObject* pyob )
    {
        if( m_resolve_me ) {
            PyObject_SetItem( m_container, m_key, pyob );
            m_resolve_me = false;
        }
        set_ptr( pyob );
        return *this;
    }