Riempimento di un vettore di coppie

Question

Voglio riempire un vettore con 8 coppie. Ogni coppia rappresenta le mosse in coordinate xey di un cavaliere in una partita di scacchi. Al momento lo sto facendo in questo modo

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

Sto facendo questo per conoscere la libreria Std. Questo sembra un modo irrimediabilmente inefficiente per risolvere questo problema.

Chiunque ha una soluzione più elegante?

Answer 1

Loops per il salvataggio:

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

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

Answer 2

Se si dispone di C++ 11 (in caso contrario non è possibile scrivere >>), è possibile utilizzare il seguente:

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

Answer 3

Se non si dispone di C++ 11 si possono utilizzare make_pair, pre -Allocare lo spazio per il vettore senza inizializzare gli elementi usando reserve e quindi utilizzare push_back senza che vengano effettuate nuove allocazioni.

Ad esempio:

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

Anche se si dispone di C++ 11 Questa tecnica è utile se è necessario calcolare gli elementi al volo, piuttosto che dura loro codice.

Answer 4

Prova che:

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

Initializer list insieme inizializzazione uniforme dà un sacco di potenza 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); 

alternativa in C++ 11:

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

Answer 6

Ecco un altro metodo di facendo la stessa cosa

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

Usage:

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: A condizione che non si sta usando C++ 11, questo sarebbe un modo. Altrimenti, suggerirei di seguire la via suggerita da @ipc.

Answer 7

Se stai usando C++ 11, si potrebbe prendere in considerazione std :: matrice invece di std :: vector. Come un normale array, l'array std ha un numero fisso di elementi e ha un senso più concettuale se si conoscono in anticipo quanti dati si utilizzano.

Answer 8

Speriamo che una versione più leggibile con i loop:

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 produce il seguente vettore:

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