Prosty sposób na sprawdzenie dużej liczby podobnych warunków?

Question

Pracuję nad grą, a ja znajduję się bardzo często sprawdzając, że pewne ilości są w granicach wskaźników przyjętych przez wektor, który reprezentuje mój świat:

if(a >= 0 && a < 16 && b >= 0 && b < 16 && c >= 0 && c < 16 && 
    d >= 0 && d < 16 && e >= 0 && e < 16) 
{ 
    //do things with vector[a][b][c][d][e] 
} 

Często trzeba sprawdzić jeszcze bardziej warunki niż to. Czy istnieje sposób, aby sprawić, by te kontrole były bardziej zwięzłe i/lub łatwiejsze do odczytania?

Czy istnieje sposób, w jaki mogę całkowicie uniknąć przeprowadzania kontroli? Wektor to 16x16x16x16x16; czy mogę zrobić tak, że gdybym miał dać mu 16 jako indeks, nie zrobiłoby to nic zamiast segfault?

Answer 1

Mogłeś napisać o zmiennej liczbie argumentów check funkcji :

bool check(int a) { 
    return 0 <= a && a < 16; 
} 

template<typename... Args> 
bool check(int a, Args... args) { 
    return check(a) && check(args...); 
} 

Można go używać jak check(a, b, c, d, e, ...). Ma także tę zaletę, że jest w stanie przyjąć dowolną liczbę warunków.

Here's a demo

Answer 2

Celem funkcji jest możliwość ponownego użycia. Jeśli często piszesz kilka długich wyrażeń lub grup zdań, być może nadszedł czas, aby je zrestrukturyzować.

W tym przypadku, chciałbym napisać prostą funkcję do zrobienia sprawdzanie bounds:

bool isInBounds(int a, int b, int c, int d, int e) 
{ 
    return a >= 0 && a < 16 && 
      b >= 0 && b < 16 && 
      c >= 0 && c < 16 && 
      d >= 0 && d < 16 && 
      e >= 0 && e < 16; 
} 

następnie używać go zamiast długiej warunkiem:

if (isInBounds(a, b, c, d, e)) 
{ 
    // do things with array[a][b][c][d][e] 
} 

Answer 3

można przechowywać zmienne jako elementów w std::vector zamiast oddzielnych variabes jak ten:

bool test(const std::vector<int>& values) 
{ 
    for(auto v: values) 
     if(v < 0 || v >= 16) 
      return false; 
    return true; 
} 

Alternatywnie, jeśli używasz C++11 lub później można użyć std::all_of:

if(std::all_of(std::begin(values), std::end(values), 
    [](int i){ return i >= 0 && i < 16; })) 
{ 
    // do stuff with values 
} 

W takim przypadku można również użyć numeru std::array .

Answer 4

Można połączyć 5 liczb całkowitych tworzących indeks w jeden std::array lub własną klasę.

using Index5 = std::array<int, 5>; 

Następnie można napisać funkcję, jak:

bool contains(Index5 bounds, Index5 point) { 
    for (Index5::size_type d = 0; d != bounds.size(); ++d) { 
     if ((unsigned)point[d] > bounds[d]) // using the trick mentioned in comments 
      return false; 
    } 
    return true; 
} 

następnie używać go tak:

auto bounds = Index5{16, 16, 16, 16, 16}; 
auto point = Index5{a, b, c, d, e}; 

if (contains(bounds, point)) { 
    // do things with point 
} 

Generalnie chciałbym zaproponować użyciu coś jak Index5 zamiast zarządzania pięć liczb całkowitych.

Answer 5

Oto kompaktowy i skuteczny sposób na sprawdzenie. Zakłada arytmetyczne uzupełnienie dwójki.

bool IsInBounds(int a, int b, int c, int d, int e) 
{ 
    // Make sure only bits 0-3 are set (i.e. all values are 0-15) 
    return ((a | b | c | d | e) & ~0xf) == 0; 
} 

Działa od stwierdzenia, że ​​wszystkie wartości spoza zakresu 0-15 wszystkie mają ustawiony bit, który nie jest jednym z czterech najmniej znaczących nich, a wszystkie wartości wewnątrz zakresu nie.

Oczywiście warto korzystać z tego rodzaju optymalizacji, jeśli zyski w zakresie wydajności przeważają nad utratą czytelności kodu.

Answer 6

Jeżeli ilości a, b, c, d i e są czymś, co występuje razem dość często i wszyscy muszą pozostać w granicach swojego „świata” (np reprezentują one „państwo” czegoś w tamten świat) to może mieć sens zdefiniowanie klasy, której głównym celem jest utrzymywanie jednego "stanu" składającego się z tych pięciu ilości.

Następnie upewnij się, że jeśli kod kiedykolwiek stara się przechowywać wartości w obiekcie tej klasy, które nie mieszczą się w granicach, coś rozsądnego (nie wysypać) dzieje zamiast i żadnych out-of-granice wartości są tam zawsze przechowywane. ten sposób obiekt tej klasy jest bezpiecznie przejść do dowolnej funkcji wymaga a, b, c, d i e się w ryzach, i nie ma potrzeby takiej funkcji robić granice sprawdzanie na tych pięciu wartościach.