Question

所以我调用辅助函数vertex_triangle，允许我接受vector<pair<T, T>>并将它们转换为有序三角形，然后将它们放入vector in那个命令。我正在使用它作为我的返回对象：

template <Typename T>
struct Triangle {
    Triangle(const pair<T, T>& first, const pair<T, T>& second, const pair<T, T>& third) {
         data[0] = first;
         data[1] = second;
         data[2] = third;
    }
    pair<T, T> data[3];
};

所以我的缠绕辅助功能看起来像这样：

template<typename T> 
triangle<T> vertex_triangle(const size_t index, const 
vector<pair<T, T>>& polygon){
    if (0 == index){
        return Triangle(polygon.back(), polygon.front(), polygon[1]);
    }else if (index == (polygon.size() - 1)){
        return Triangle(polygon[polygon.size() - 2], polygon.back(), polygon.front());
    }else{
        return Triangle(polygon[index - 1], polygon[index], polygon[index + 1]);
    }
 }

最初我直接将回报放在vector<Triangle<T>> foo这样的意义上：

foo.push_back(vertex_triangle(i, bar))

现在我需要使用vector<pair<T, T>> foo所以我必须解压缩vertex_triangle的回复：

const auto temp = vertex_triangle(i, bar);

foo.push_back(temp[0]);
foo.push_back(temp[1]);
foo.push_back(temp[2]);

但我真的不喜欢临时对象，有没有办法以某种方式返回我想要将bar的顶点推入foo而不返回点的副本，解包的顺序他们，一个一个地推回去？

Answer 1

所以your comment on using an out parameter是这里最直接的选择。另一种选择是返回一个lambda，它将通过引用捕获您的输入。例如：

template <typename T>
auto vertex_triangle(const size_t index, const vector<pair<T, T>>& polygon) {
    const auto& first = index == 0U ? polygon.back() : polygon[index - 1U];
    const auto& second = polygon[index];
    const auto& third = index == size(polygon) - 1U ? polygon.front() : polygon[index + 1U];

    return [&](auto& output){ output.push_back(first);
                              output.push_back(second);
                              output.push_back(third); };
}

可以像这样调用：

vertex_triangle(i, bar)(foo)

Live Example

没有矢量返回订购

1 个答案: