2016-04-12 3 views
1

Существует простая функция, которую я хотел бы добавить к одному из членов класса: я хотел бы выйти из функции в случае, если все значения некоторого boolean (2d): true.Выход из функции, если все значения в массиве истинны

В более простом случае 1d массива, я могу сделать это следующим образом:

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 

Там, вероятно, не более быстрый способ сделать это (минус маргинальные оптимизаций), но я считаю, это немного некрасиво. Есть ли лучшие способы сделать это?

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

В конец я решил реализовать:

{ 
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; 
} 
+1

'станд :: all_of' .. –

ответ

3

Вы можете использовать std::all_of из <algorithm>:

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

Что делать, если это' bool ** 'объект? Я выбрал 'vector' в моем примере, чтобы инициализировать его в одной строке, но в моем коде я использовал' bool ** '. Могу ли я 'std :: all (myArray [0] [0], myArray [Size1-1] [Size2-1])'? –

+1

С помощью 'bool [N] [M]' вы можете сделать что-то вроде 'std :: all_of (& myArray [0] [0], & myArray [N] [0], [] (bool b) {return b; }) '. Но с 'bool **' вы должны вызвать что-то вроде: 'std :: all_of (& myArray [0], & myArray [N], [M] (const bool * bs) {return std :: all_of (bs, bs + M, [] (bool b) {return b;});}); ' – Jarod42

+0

Большое спасибо, он выполняет эту работу. –

0

может быть и-ки все значения? Таким образом:

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

Или std::all_of если ваш знакомый с итераторы и лямбды.

+0

Спасибо за ввод, возможно, даже 'i

0

Для 2d вектора, вы можете разбить его:

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


} 
1

Одно из решений:

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 
+0

спасибо, я не знал, что этот трюк для «сглаживания» массива, может быть полезен в будущем. –