Beenden einer Funktion, wenn alle Werte in einem Array wahr sind

Question

Es gibt eine einfache Funktion, die ich zu einem der Mitglieder einer Klasse hinzufügen möchte: Ich möchte die Funktion beenden, falls alle Werte eines booleschen (2d) Array sind true.

Im einfacheren Fall eines 1d Array ich es auf diese Weise tun:

int SIZE = 10; 
std::vector<bool> myArray(SIZE, true); 
int i = 0; 
while(myArray[i] and i < SIZE){ 
    ++i; 
    } 
if(i == SIZE){ 
    return; 
    } 
// rest of the code for array not all true 

Es gibt wohl keinen schnelleren Weg, um es (minus marginal Optimierungen) zu tun, aber ich finde es ein bisschen hässlich. Gibt es bessere Möglichkeiten, es zu tun?

=========================================

In das Ende entschied ich mich zu implementieren:

{ 
bool allTrue = true; 
for(int i = 0; i < SIZE1 and allTrue; ++i) 
    for(int j = 0; j < SIZE2 and allTrue; ++j) 
     allTrue &= myArray[i][j]; 
if(allTrue) 
    return; 
} 

Answer 1

Sie std::all_of von <algorithm> verwenden:

alle Werte

if (std::all_of(myArray.begin(), myArray.end(), [](bool b) {return b;})) { 
    return; 
} 

Answer 2

Mai und-ing? Auf diese Weise:

bool r = true; 
for (int i=0; i<myArray.size() && r; i++) r &= myArray[i]; 
return r; 

Oder std::all_of, wenn Ihr mit Iteratoren und Lambda-Ausdrücke vertraut sind.

Answer 3

für ein 2D-Vektor, möchten Sie vielleicht, es brechen:

#include <vector> 
#include <algorithm> 


bool all_true(const std::vector<bool>& v) 
{ 
    return std::all_of(std::begin(v), std::end(v), [](const auto& b) { return b; }); 
} 

bool all_true(const std::vector<std::vector<bool>>& vv) 
{ 
    return std::all_of(std::begin(vv), std::end(vv), [](const auto& v) { 
    return all_true(v); 
    }); 
} 

void test() 
{ 
    std::vector< std::vector<bool> > d2 /* = initalise 2d vector */; 


    while(!all_true(d2)) 
    { 
    // things you want to do 
    } 


} 

Answer 4

Eine der Lösungen:

int my2Da[][2] = {{true, true},{true, true},{true, true}}; 
int *pa = my2Da[0]; 
bool flag=true; 
for (int i=0;flag && i<(sizeof my2Da)/(sizeof (int));flag &= pa[i++]); 
//flag indicates about the result