Füllen eines Vektors von Paaren

Question

Ich möchte einen Vektor mit 8 Paaren füllen. Jedes Paar repräsentiert die Züge in x- und y-Koordinaten, die ein Ritter in einem Schachspiel machen kann. Im Moment mache ich es so

vector<pair<int,int>> moves[8]; 

pair<int,int> aPair; 
aPair.first = -2; 
aPair.second = -1; 
moves[0].push_back(aPair); 
aPair.first = -2; 
aPair.second = 1; 
moves[1].push_back(aPair); 
aPair.first = -1; 
aPair.second = -2; 
moves[2].push_back(aPair); 
aPair.first = -1; 
aPair.second = 2; 
moves[3].push_back(aPair); 
aPair.first = 1; 
aPair.second = -2; 
moves[4].push_back(aPair); 
aPair.first = 1; 
aPair.second = 2; 
moves[5].push_back(aPair); 
aPair.first = 2; 
aPair.second = -1; 
moves[6].push_back(aPair); 
aPair.first = 2; 
aPair.second = 1; 
moves[7].push_back(aPair); 

Ich mache das, um über die Std-Bibliothek zu lernen. Dies scheint ein hoffnungslos ineffizienter Weg zur Lösung dieses Problems zu sein.

Wer hat eine elegantere Lösung?

Answer 1

Loops zur Rettung:

for(int k = 0; k < 2; k++) 
    for(int i = -1; i < 2; i += 2) 
     for(int j = -1; j < 2; j+= 2) 
      result.push_back(make_pair(i * (k+1), j * (((k + 1) % 2) + 1))); 

Ausgang: http://ideone.com/2B0F9b

Answer 2

Wenn Sie C++ 11 (sonst kann man nicht >> schreiben), wird die folgende verwenden:

vector<pair<int,int>> moves = { 
    {-2, -1}, 
    {-2, 1}, 
    {-1, -2}, 
    {-1, 2}, 
    { 1, -2}, 
    { 1, 2}, 
    { 2, -1}, 
    { 2, 1} 
}; 

Answer 3

Wenn Sie C 11 nicht haben ++ können Sie make_pair, Pre nutzen - Weisen Sie den Platz für den Vektor zu, ohne die Elemente mithilfe der Reserve zu initialisieren, und verwenden Sie dann push_back, ohne dass neue Zuordnungen vorgenommen werden.

Zum Beispiel:

vector<pair<int,int> > moves; 
moves.reserve(8); 
moves.push_back(make_pair(-2, -1)); 
    // and so on 

Auch wenn Sie C++ 11 diese Technik nützlich, wenn Sie die Elemente im Fluge, anstatt hart Code um sie berechnen müssen.

Answer 4

bereit:

vector<pair<int,int>> moves{{-2, -1}, {2, 1}, {-1, -2}, {-1, 2}, 
          {1, -2}, {1, 2}, {2, -1}, {2, 1}}; 

Initializer list zusammen mit Uniform Initialisierung gibt eine Menge Energie in C++ 11.

Answer 5

In C++ 98/03:

moves.push_back(std::make_pair(-2, -1)); 

In C++ 11:

moves.emplace_back(-2, -1); 

Alternativ in C++ 11:

std::vector<std::pair<int, int>> moves = { { -2, -1}, ... }; 

Answer 6

Hier ist eine andere Methode das gleiche tun.

template <class VectorClass> 
class CreateVector 
{ 
public: 
    typedef typename VectorClass::value_type value_type; 
    CreateVector(const value_type& value) 
    { 
     mVector.push_back(value); 
    } 

    CreateVector& operator()(const value_type& value) 
    { 
     mVector.push_back(value); 
     return *this; 
    } 

    inline operator VectorClass() const 
    { 
     return mVector; 
    } 
private: 
    VectorClass mVector; 
}; 

Verbrauch:

vector<pair<int,int>> moves = CreateVector<vector<pair<int,int> > > 
(make_pair(1,2)) 
(make_pair(2,3)) 
(make_pair(3,4)) 
(make_pair(4,5)); 

EDIT: Vorausgesetzt, Sie sind nicht C++ 11 verwendet wird, wäre dies ein Weg sein. Ansonsten würde ich vorschlagen, den von @ipc vorgeschlagenen Weg zu gehen.

Answer 7

Wenn Sie mit C++ 11, möchten Sie vielleicht std :: Array statt std :: vector betrachten. Wie ein normales Array hat das std-Array eine feste Anzahl von Elementen und macht mehr konzeptionellen Sinn, wenn Sie im Voraus wissen, wie viele Daten Sie verwenden.

Answer 8

hoffentlich eine lesbare Version mit Schlaufen:

vector<pair<int, int>> result; 
for(int moveX=1; moveX<=2; moveX++) 
{ 
    for(int signX=-1; signX<=1; signX+=2) 
    { 
     for(int signY=-1; signY<=1; signY+=2) 
     { 
      result.push_back(make_pair(moveX*signX, (3-moveX)*signY)); 
     } 
    } 
} 

Full program erzeugt den folgenden Vektor:

{-1, -2}, 
{-1, 2}, 
{1, -2}, 
{1, 2}, 
{-2, -1}, 
{-2, 1}, 
{2, -1}, 
{2, 1},