如何为std::vector<vector3f>实现代理（不暴露vector3f）并保留元素引用？

你当前的代码返回临时Vec3f对象的引用，属于未定义行为。要保留对impl内部Vector2d的引用，必须用代理类包装内部的2D向量，让代理类模拟Vec3f的接口，所有操作直接转发给内部的Vector2d。

实现代码 #

首先定义代理类：

class Vec3fProxy {
private:
    Base::Vector2d& _inner; // 持有内部2D向量的引用
public:
    Vec3fProxy(Base::Vector2d& v) : _inner(v) {}

    // 模拟Vec3f的只读坐标访问（z固定为0）
    float x() const { return _inner.x; }
    float y() const { return _inner.y; }
    float z() const { return 0.0f; }

    // 支持修改x/y坐标（z无对应内部字段，不提供修改接口）
    void setX(float val) { _inner.x = val; }
    void setY(float val) { _inner.y = val; }

    // 支持直接赋值Vec3f（自动忽略z值）
    Vec3fProxy& operator=(const Vec3f& rhs) {
        _inner.x = rhs.x;
        _inner.y = rhs.y;
        return *this;
    }

    // 隐式转换为Vec3f（用于只读场景）
    operator Vec3f() const {
        return Vec3f(_inner.x, _inner.y, 0.0f);
    }
};

修改Poly2D的operator[]：

// 非const版本，支持修改
Vec3fProxy Poly2D::operator[](size_t i) {
    return Vec3fProxy((*impl->polygon2d)[i]);
}

// const版本，仅支持只读访问
const Vec3fProxy Poly2D::operator[](size_t i) const {
    return Vec3fProxy((*impl->polygon2d)[i]);
}

通过双层代理实现：一层代理单个Vec3f元素，只暴露必要操作；另一层代理整个vector，对外屏蔽Vec3f和std::vector的内部细节。

实现代码 #

1. 单个Vec3f的元素代理

// 非const元素代理（支持修改）
class Vec3ElementProxy {
private:
    Vec3f& _inner;
public:
    Vec3ElementProxy(Vec3f& v) : _inner(v) {}

    float getX() const { return _inner.x; }
    float getY() const { return _inner.y; }
    float getZ() const { return _inner.z; }

    void setX(float val) { _inner.x = val; }
    void setY(float val) { _inner.y = val; }
    void setZ(float val) { _inner.z = val; }
};

// const元素代理（仅支持只读）
class ConstVec3ElementProxy {
private:
    const Vec3f& _inner;
public:
    ConstVec3ElementProxy(const Vec3f& v) : _inner(v) {}

    float getX() const { return _inner.x; }
    float getY() const { return _inner.y; }
    float getZ() const { return _inner.z; }
};

2. 整个std::vector<Vec3f>的代理类

class Vec3VectorProxy {
private:
    std::vector<Vec3f>& _innerVec;
public:
    Vec3VectorProxy(std::vector<Vec3f>& vec) : _innerVec(vec) {}

    // 元素访问
    Vec3ElementProxy operator[](size_t i) {
        return Vec3ElementProxy(_innerVec[i]);
    }

    const ConstVec3ElementProxy operator[](size_t i) const {
        return ConstVec3ElementProxy(_innerVec[i]);
    }

    // 对外暴露常用的vector操作
    size_t size() const { return _innerVec.size(); }
    void push_back(float x, float y, float z) {
        _innerVec.emplace_back(x, y, z);
    }
    void clear() { _innerVec.clear(); }

    // 简化版迭代器（支持范围for循环）
    class Iterator {
    private:
        std::vector<Vec3f>::iterator _it;
    public:
        Iterator(std::vector<Vec3f>::iterator it) : _it(it) {}

        Vec3ElementProxy operator*() { return Vec3ElementProxy(*_it); }
        Iterator& operator++() { ++_it; return *this; }
        bool operator!=(const Iterator& other) const { return _it != other._it; }
    };

    Iterator begin() { return Iterator(_innerVec.begin()); }
    Iterator end() { return Iterator(_innerVec.end()); }
};

完整可运行示例 #

#include <iostream>
#include <vector>

// 假设的Vec3f定义
struct Vec3f {
    float x, y, z;
    Vec3f(float x_, float y_, float z_) : x(x_), y(y_), z(z_) {}
};

// 假设的Base::Vector2d定义
namespace Base {
    struct Vector2d {
        float x, y;
    };
}

// 上面的所有代理类定义...

// Poly2D简化实现
class Poly2D {
private:
    struct Impl {
        std::vector<Base::Vector2d>* polygon2d;
        Impl() : polygon2d(new std::vector<Base::Vector2d>()) {
            polygon2d->push_back({1.0f, 2.0f});
            polygon2d->push_back({3.0f, 4.0f});
        }
        ~Impl() { delete polygon2d; }
    };
    Impl* impl;
public:
    Poly2D() : impl(new Impl()) {}
    ~Poly2D() { delete impl; }

    Vec3fProxy operator[](size_t i) {
        return Vec3fProxy((*impl->polygon2d)[i]);
    }

    const Vec3fProxy operator[](size_t i) const {
        return Vec3fProxy((*impl->polygon2d)[i]);
    }
};

int main() {
    // 测试Poly2D代理
    Poly2D poly;
    std::cout << "Poly2D[0] x: " << poly[0].x() << ", y: " << poly[0].y() << ", z: " << poly[0].z() << "\n";
    poly[0].setX(5.0f);
    std::cout << "修改后Poly2D[0] x: " << poly[0].x() << "\n";

    // 测试Vec3VectorProxy
    std::vector<Vec3f> innerVec;
    Vec3VectorProxy vecProxy(innerVec);
    vecProxy.push_back(1.0f, 2.0f, 3.0f);
    vecProxy.push_back(4.0f, 5.0f, 6.0f);
    std::cout << "代理vector大小: " << vecProxy.size() << "\n";
    std::cout << "vecProxy[1] z: " << vecProxy[1].getZ() << "\n";
    vecProxy[1].setZ(9.0f);
    std::cout << "修改后vecProxy[1] z: " << vecProxy[1].getZ() << "\n";

    // 范围for循环测试
    std::cout << "遍历代理vector:\n";
    for (auto elem : vecProxy) {
        std::cout << elem.getX() << ", " << elem.getY() << ", " << elem.getZ() << "\n";
    }

    return 0;
}

核心说明 #

1. 所有代理类都持有内部对象的引用，避免复制临时对象，保证操作直接作用于原始数据。
2. 对外仅暴露业务需要的接口，完全屏蔽Vec3f、Base::Vector2d的内部结构。
3. 同时提供const版本的代理，确保const对象的访问安全。

内容的提问来源于stack exchange，提问作者Mary Guty