C++ Was ist der beste Weg, um diese 8-Bit-Schleife zu beenden

Question

Ist es möglich, dies für Schleife kürzer oder eleganter zu schreiben, ohne uint16_t zu verwenden? Es gibt einen Überlauf, wenn i0xFF erreicht.

for (uint8_t i = 0; i <= 0xFF; i++) 
{ 
    // do something 
    if (i == 0xFF) 
     break; 
} 

Answer 1

das gesamte Spektrum abzudecken, müssen wir nur noch nach dem Körper der Schleife den Test zu tun, so dass ein tun mit ... während eine schöne Passform ist hier:

uint8_t i = 0; 
do { 
... 
} while (i++ < 0xFF); 

Answer 2

Als Überlauf für Zahlen ohne Vorzeichen gut definiert sind, kann diese Schleife es tun:

uint8_t i = 0; 
do { 
    // use i here 
    i++; 
} while (i); 

i Überlauf (0 wird) an der 256. Iteration und die während stoppt, weil die Bedingung falsch ist.

Hinweis: Dieser Trick lohnt sich nur, wenn Sie auf einer < 32-Bit-Plattform sind. Auf> = 32-Bit-Plattformen besteht eine hohe Wahrscheinlichkeit, dass dieser Trick in eine Schleife umgewandelt wird, die einen 32-Bit breiten Zähler verwendet.

Auf der anderen Seite, auf 8-Bit-Plattformen, denke ich, dass dies die effizienteste und kleinste 256-Iterationsschleife ist.

Answer 3

Nicht die kürzeste, aber die coolste Möglichkeit ist, ein Array mit allen möglichen Werten von uint8_t zu deklarieren und darüber zu iterieren.

#include <iostream> 
#include <cstdint> 
#include <limits> 

namespace detail { 
template<typename int_t, int_t cnt, bool not_done, int_t... rest> 
struct range_impl { 
    static constexpr auto& value = range_impl<int_t, cnt - 1, 
     (cnt - 1) != std::numeric_limits<int_t>::min(), cnt, rest...>::value; 
}; 

template<typename int_t, int_t cnt, int_t... rest> 
struct range_impl<int_t, cnt, false, rest...> { 
    static constexpr int_t value[] = { cnt, rest... }; 
}; 

template<typename int_t, int_t cnt, int_t... rest> 
constexpr int_t range_impl<int_t, cnt, false, rest...>::value[]; 
} // detail 

template<typename int_t> 
struct range : public detail::range_impl<int_t, std::numeric_limits<int_t>::max(), true> {}; 

int main(int argc, char** argv) { 
    for(uint8_t i: range<uint8_t>::value) { 
     std::cout << (int) i << std::endl; 
    } 

    for(int8_t i: range<int8_t>::value) { 
     std::cout << (int) i << std::endl; 
    } 
} 

Die Struktur range generiert das Array in Kompilierzeit. Dieser Code kann für jeden Integer-Typ verwendet werden.