4

我有以下代码，表示 3D 应用程序中的网格（为清楚起见省略了一些代码）：

class Mesh {
public:
    typedef std::vector<Vertex> Vertices;
    typedef std::vector<int> Elements;

    template<class VerticesIt, class ElementsIt>
    Mesh(const VerticesIt verticesBegin,
         const VerticesIt verticesEnd,
         const ElementsIt elementsBegin,
         const ElementsIt elementsEnd) :
    vertices_(verticesBegin, verticesEnd),
    elements_(elementsBegin, elementsEnd) {
    }        
    virtual ~Mesh();

    typename Vertices::const_iterator verticesBegin() const {
        return vertices_.begin();
    };

    typename Vertices::const_iterator verticesEnd() const {
        return vertices_.end();
    };

    typename Elements::const_iterator elementsBegin() const {
        return elements_.begin();
    };

    typename Elements::const_iterator elementsEnd() const {
        return elements_.end();
    };

private:       
    Vertices vertices_;
    Elements elements_;

};

它工作得很好，为内部数据提供了一个清晰的界面。没有公开容器的实现细节。

不过，我对此有一点小问题。我不能使用基于范围的 for 循环，必须使用迭代器：

for (auto it = mesh.verticesBegin(); it != mesh.verticesEnd(); ++it) {
// Do stuff
}

for (auto it = mesh.elementsBegin(); it != mesh.elementsEnd(); ++it) {
// Do stuff
}

对我的口味来说有点冗长。我的首选客户端代码将如下所示：

for(auto & vert : mesh.vertices) {
// Do stuff.
}

for(auto & element : mesh.elements) {
// Do stuff.
}

是否可以在不暴露容器的实现细节的情况下实现这一点？另外，我不想将容器包装到自定义类中，因为我希望完全访问 Mesh 类中的所选容器（std::vector）。

4

4 回答 4

10

您可以使用某种代理，例如：

template<typename Container>
class ConstIteratorProxy
{
public:
    ConstIteratorProxy(const Container& container) : container_(container) { }
    typename Container::const_iterator begin() const {
        return container_.begin();
    };
    typename Container::const_iterator end() const {
        return container_.end();
    };
private:
    const Container& container_;
};

在网格中：

ConstIteratorProxy<Vertices> vertices() const {
    return ConstIteratorProxy<Vertices>(vertices_);
}
ConstIteratorProxy<Elements> elements() const {
    return ConstIteratorProxy<Elements>(elements_);
}

然后使用它：

Mesh m;
for (auto& v : m.vertices()) { }
for (auto& e : m.elements()) { }
于 2014-08-03T15:06:13.673 回答
3

将您的函数verticesBegin和分别重命名verticesEnd为begin和end。然后你就可以这样写：

for(auto & vert : mesh) 
{
// Do stuff.
}

请注意，基于范围的for循环期望您的容器具有begin和end作为成员函数 - 或自由函数begin并将end您的容器作为参数。

还要注意，基于范围的 for 循环不能迭代两个东西——mesh可以表现得像一个容器，而不是两个。所以如果你也想迭代索引，那么你必须公开它，或者抽象它然后公开顶点。

或者您可以编写一个 zip 迭代器，它将在单个 for 循环中同时迭代两个容器。

于 2014-08-03T14:38:20.963 回答
0

您可以返回一个迭代器包装器vertices()和elements()可以传递给 for 循环的函数，例如

template<typename T>
class iterator_wrapper
{
public:
  iterator_wrapper(const typename std::vector<T>::const_iterator &begin_,
                   const typename std::vector<T>::const_iterator &end_)
    :m_begin(begin_), m_end(end_) {}
  typename std::vector<T>::const_iterator begin() const {return m_begin;}
  typename std::vector<T>::const_iterator end() const {return m_end;}

private:
  typename std::vector<T>::const_iterator m_begin, m_end;
};

在网格类中定义vertices()和elements()函数：

iterator_wrapper<Vertex> vertices() {return iterator_wrapper<Vertex>(vertices_.begin(), vertices_.end());}
iterator_wrapper<int> elements()    {return iterator_wrapper<int>(elements_.begin(), elements_.end());}

然后这样称呼它：

for(auto &vert:mesh.vertices())
{
  //....
}

for(auto &element:mesh.elements())
{
  //....
}
于 2014-08-03T15:04:00.827 回答
0

使用代理存储两个迭代器并实现 begin 和 end 方法非常容易：

#include <iostream>
#include <vector>

template <typename T>
struct PairIt {
    PairIt(T&& b, T&& e) : b_{std::forward<T>(b)}, e_{std::forward<T>(e)} {}
    T begin() const { return b_; }
    T end() const { return e_; }
private:
    T b_,e_;
};

std::vector<int> badglobal { 1, 2, 3 };

PairIt<std::vector<int>::iterator> ForRangeProxy() {
    return { begin(badglobal), end(badglobal) };
};

int main() {
    for( auto v : ForRangeProxy() )
        std::cout << v << std::endl;
}

ForRangeProxy您可以为您的对象想要授予访问权限的每个集合实现几个。

于 2014-08-03T14:54:07.223 回答