Return Bestellung ohne einen Vektor

Question

So rufe ich eine Hilfsfunktion, vertex_triangle, ziemlich ein bisschen, um mir zu ermöglichen, in einem vector<pair<T, T>> nehmen und wickeln sie in geordnete Dreiecke, dann legen Sie diese in einer vector in dieser Reihenfolge. Ich benutze dies als meine Rückkehr Objekt:

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

So sieht meine Wickelhilfsfunktion wie folgt aus:

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

Ursprünglich war ich direkt die Rückkehr in einem vector<Triangle<T>> foo wie dies alles Sinn gemacht Abdrucken:

foo.push_back(vertex_triangle(i, bar)) 

Jetzt muss ich einen vector<pair<T, T>> foo verwenden, so würde ich die Rückkehr von vertex_triangle auszupacken:

const auto temp = vertex_triangle(i, bar); 

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

Aber ich weiß nicht wirklich wie das temporäre Objekt, ist es eine Möglichkeit, irgendwie die zurückkehren, um das schiebe ich von bar in foo die verts wollen, ohne eine Kopie der Punkte zurückkehrt, Auspacken ihnen, und sie drängen zurück eins nach dem anderen?

Answer 1

So ist your comment on using an out parameter die direkteste Option hier. Die andere Alternative wäre, ein Lambda zurückzugeben, das Ihre Eingaben als Referenz erfasst. So zum Beispiel:

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

könnte wie folgt aufgerufen werden:

vertex_triangle(i, bar)(foo) 

Live Example