En boucle dans un tableau multidimensionnel?

Question

Comment naviguer dans un tableau multidimensionnel? Disons que nous avions quelque chose comme ceci:

class blah 
{ 
    public: 
    blah(); 
    bool foo; 
}; 

blah::blah() 
{ 
    foo = true; 
} 

blah testArray[1][2]; 
testArray[1][0].foo = false; 

Comment pourrais-je aller sur une boucle à travers testArray pour trouver un des foo est faux?

Answer 1

class blah 
{ 
    public: 
    blah(); 
    bool foo; 
}; 

blah::blah() 
{ 
    foo = true; 
} 

int testArrayFirstLength = 1; 
int testArraySecondLength = 2; 

blah testArray[testArrayFirstLength][testArraySecondLength]; 
testArray[1][0].foo = false; 


for (int i = 0; i < testArrayFirstLength; i++) { 
    for (int j = 0; j < testArraySecondLength; j++) { 
     if (!testArray[i][j]) { 
      blah thing = testArray[i][j] 
     } 
    } 
} 

C'est bon? Ou cherchiez-vous quelque chose d'autre?

Answer 2

int x = 0; 
int y = 0; 

for(x = 0; x < 1; x++){ 
    for(y = 0; y < 2; y++){ 
     if(testArray[x][y].foo == false){ 
      //yeah! 
     } 
    } 
} 

Answer 3

for (std::size_t i(0); i != 1; ++i){ 
    for (std::size_t j(0); j != 2; ++j) { 
     if (!testArray[i][j].foo) { 
      //testArray[i][j].foo is false 
      //Perform the required operation 
     } 
    } 
} 

Answer 4

Celui-ci ne dépend pas de nombres magiques:

#include <cstddef> 
for (size_t x = 0; x < sizeof(*testArray)/sizeof(**testArray); ++x) 
for (size_t y = 0; y < sizeof(testArray)/sizeof(*testArray); ++y) { 
    if (testArray[x][y].foo == false) { 

    } 
} 

Avoir x dans la boucle externe conduit à une meilleure mise en cache.

Answer 5

testé dans C++ +14 (en utilisant des pointeurs, donc être sûr)

#include <iostream> 
int main() 
{ 
int array[2][2][2]; 
int* pointer=&array[0][0][0]; 
for(int i=0; i<2*2*2; i++) 
    { 
     std::cout<<*pointer<<std::endl;  
     pointer++; 
    } 
}