код разъединения для подсчета от 0 до 255 использующих 8-разрядных типов данных

Я не уверен, что вы имеете в виду, но

 uint8_t i = 0;

 do {
    ...
 } while (++i & 255) ;

должен делать то, что вы просите, и имеет явную ссылку на 255 (бесполезно, если ваш компилятор соответствует стандарту C99, а uint8_t действительно 8 бит).

Кажется, вы хотите передать сообщение о подсчете от 0 до 255 в зависимости от типа данных, который вы используете, но каково значение 255? Вероятно, вам следует # определить это магическое число с именем, явно указывающим его назначение. Кроме того, комментарий над оператором был бы более полезным, чем попытка «закодировать» всю эту информацию в несколько странно выглядящих утверждениях.

Например:

#define MAX_RETRIES   255
unsigned int retries;

for(retries = 0; retries <= MAX_RETRIES; ++retries)
{
  do_retry_work();
}

Если необходимо, добавьте комментарий, почему количество повторных попыток ограничено на 255.

Счет на две половины?

uint8_t k = 0;
while (k & 0x80 == 0) {
  work();
  k++;
}
while (k & 0x80 == 1) {
  work();
  k++;
}

Я не сам пробовал, но может сработать:
Получите представление для аннотации с помощью метода MKMapView - (MKAnnotationView *) viewForAnnotation: (id ) annotation и установите для него новое изображение.

Edit: Пытался сделать это я и этот подход у меня отлично сработали:

//  Function where you got new image and want to set it to annotation view
for (MyAnnotationType* myAnnot in myAnnotationContainer){
    MKAnnotationView* aView = [mapView viewForAnnotation: myAnnot];
    aView.image = [UIImage imageNamed:@"myJustDownloadedImage.png"];
}

После вызова этого метода все изображения аннотаций были обновлены.

i = 255;
do {
 work();
} while (i--);

Вы тратите столько усилий, чтобы сэкономить один байт? Ваш последний пример подойдет, или вы могли бы сделать какую-то комбинацию первого и третьего:

for (uint8_t i = 0;;++i)
{
   work();
   if (i == 255)
       break;
}

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

Что ж, если вы хотите сделать нечеткий код ясным, вы всегда можете добавить комментарий;)

Одно из решений - поместить тело цикла в функцию (или макроса, если публичная порка не вызывает беспокойства), а затем:

uint8_t i ;
for( i = 0; i < 255; i++ )
{
    body(i) ;
}
body(i) ;

или если вы не хотите расширять область действия i и применяются правила области C ++:

for( uint8_t i = 0; i < 255; i++ )
{
    body(i) ;
}
body(255) ;

for (uint8_t i(0); (int)i <= 255; ++i)

Мне это кажется совершенно ясным.

Даже если вы пытаетесь использовать 1-байтовый счетчик, ваш компилятор может вместо этого превратить его в следующее:

for (int ii(0); ii <= 255; ++ii) {
    uint8_t i(ii);
    ...
}

Например, GCC делает, потому что это быстрее.

$ cat >test.c
void foo(char);
void bar(void) {
    char i;
    for (i = 0; i <= 255; i++)
        foo(i);
}
^D
$ cc -m32 -c -O3 test.c
$ objdump -d test.o

test.o:     file format elf32-i386


Disassembly of section .text:

00000000 <bar>:
   0:   55                      push   %ebp
   1:   89 e5                   mov    %esp,%ebp
   3:   53                      push   %ebx
   4:   31 db                   xor    %ebx,%ebx
   6:   83 ec 04                sub    $0x4,%esp
   9:   8d b4 26 00 00 00 00    lea    0x0(%esi,%eiz,1),%esi
  10:   89 1c 24                mov    %ebx,(%esp)
  13:   83 c3 01                add    $0x1,%ebx
  16:   e8 fc ff ff ff          call   17 <bar+0x17>
  1b:   eb f3                   jmp    10 <bar+0x10>
$ cc -m64 -c -O3 test.c
$ objdump -d test.o

test.o:     file format elf64-x86-64


Disassembly of section .text:

0000000000000000 <bar>:
   0:   53                      push   %rbx
   1:   31 db                   xor    %ebx,%ebx
   3:   0f 1f 44 00 00          nopl   0x0(%rax,%rax,1)
   8:   89 df                   mov    %ebx,%edi
   a:   83 c3 01                add    $0x1,%ebx
   d:   e8 00 00 00 00          callq  12 <bar+0x12>
  12:   eb f4                   jmp    8 <bar+0x8>

Нет, нет четкого способа сделать это в простом старом C, так как условие проверяется после приращения, и если вы сравните <= 255, вы будете зацикливаться вечно, как 8-битный значение не может превышать 255 и заканчиваться.

Так оно и становится.

uint8_t i = 0;
while (1)
{
  /* your stuff */
  if (255 == i++)
    break;
}

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

Обратите внимание, что 8-битные типы очень неэффективны во многих компиляторах, иногда создавая ненужные расширения знаков. Вместо этого вы можете использовать тип uint_least8_t, он, вероятно, расширится до размера слова вашей системы и будет работать быстрее.

Я бы предположил, что простое решение:

for (int i = 0; i < 256; ++i) {
   ...
}

также, вероятно, будет наиболее эффективным.

1. Даже если вы используете меньший (1-байтовый) тип данных. Компилятор Си будет продвигать его в любом выражении до int.

2. На 8-битном контроллере int, вероятно, 16-битный. Использование однобайтового типа сэкономит только один байт стекового пространства. И опять же компилятор может поместить эту переменную в регистр, так что экономии места все равно не будет.

Проверьте ассемблерный код, сгенерированный вышеуказанным кодом, а затем решите, нужна ли ему (или нет) оптимизация (пробел).