Comment définir l'itérateur dans différentes directions pour un tableau imbriqué de dimension N?

Question

Par exemple, j'ai un tableau 2D en utilisant le double comme type de données.

vector<vector<double> > array2D; 

// Set up sizes. (HEIGHT x WIDTH) 
array2D.resize(HEIGHT); 
for (int i = 0; i < HEIGHT; ++i) 
    array2D[i].resize(WIDTH); 

Comment pourrais-je définir des itérateurs qui peut itérer le long de la direction de la ligne pour une colonne donnée ou le long de la direction de la colonne pour une ligne donnée?

Answer 1

Vous pouvez utiliser std :: function pour visiter chaque élément (colonne ou ligne) et énumérateur.

#include <iostream> 
#include <vector> 
#include <functional> 

typedef std::vector<std::vector<int>> TTable; 

void enumerateColumn(size_t column, TTable & table, std::function<void(int&, size_t)> op) 
{ 
    for(size_t index = 0; index < table.size(); ++index) 
    { 
     op(table[index][column], index); 
    } 
} 

void enumerateRow(size_t row, TTable & table, std::function<void(int&, size_t)> op) 
{ 
    auto& row_tab = table[row]; 
    for (size_t index = 0; index < row_tab.size(); ++index) 
    { 
     op(row_tab[index], index); 
    } 
} 

int main() 
{ 
    TTable table = 
    { 
    { 1,2,3 }, 
    { 4,5,6 }, 
    { 7,8,9 } 
    }; 

    std::cout << "Show Column: " << 2 << std::endl; 
    enumerateColumn(2, table, [] (int& val, size_t index) 
    { 
     std::cout << "Index: "<< index <<" Value: "<< val << std::endl; 
    }); 

    std::cout << "Show Row: " << 1 << std::endl; 
    enumerateRow(1, table, [] (int& val, size_t index) 
    { 
     std::cout << "Index: " << index << " Value: " << val << std::endl; 
    }); 


    std::cout << "Change Column: " << 0 << std::endl; 
    enumerateColumn(0, table, [] (int& val, size_t index) 
    { 
     val = 10 * (index + 1); 
    }); 

    std::cout << "Change Row: " << 2 << std::endl; 
    enumerateRow(2, table, [] (int& val, size_t index) 
    { 
     val = 100 * (index + 1); 
    }); 

    return 0; 
} 

sortie:

Show Column: 2 
Index: 0 Value: 3 
Index: 1 Value: 6 
Index: 2 Value: 9 
Show Row: 1 
Index: 0 Value: 4 
Index: 1 Value: 5 
Index: 2 Value: 6 
Change Column: 0 
Change Row: 2 

enumerateColumn et enumerateRow fonctions visiter chaque valeur de la ligne ou la colonne demande. Pour réaliser cette itération, il suffit de définir l'index de ligne/colonne désiré. La fonction std :: est appelée pour chaque valeur de colonne/ligne, donc vous pouvez faire n'importe quelle manipulation à l'intérieur. En utilisant cette méthode, vous pouvez "cacher" le mécanisme d'itération de ligne/colonne en donnant seulement un accès facile à chaque élément de ligne/colonne.

Après les 2 dernières manipulations, le tableau de résultat aura les valeurs suivantes:

10 2 3 
20 5 6 
100 200 300