Не большой вопрос по оптимизации

[Shad0wF1rst]

Как сильно влияет на производительность проверки находящиеся в цикле?

1) Речь идет об огромных циклах.
2) Проверка осуществляется следующим образом, если найдется хоть один параметр удовлетворяющий условию, то происходит выход из цикла.
3) Расстраивается крайний случай, когда параметр удовлетворяющий условию находится в конце цикла.

[Abstraction]

Что-то не очень понятно. Влияют - по сравнению с какой альтернативой? Хотя бы в общих чертах пример можно?

[Shad0wF1rst]

Вот две ситуации
1)

char mass[1000000000];
for (int i = 0; i < 1000000000; i++) {
if (mass[i] == 10) return значение;
какие нибудь еще операции
}
return значение;

2)

for (int i = 0; i < 1000000000; i++) {
какие нибудь еще операции
}
return значение;

Все соответственно упращенно.

[Abstraction]

Второе предпочтительнее только в том случае, если вероятность срабатывания условия архимизерная (и, разумеется, блоки функционально эквивалентны). Одна проверка - это быстро, особенно в относительном выражении.
Но, разумеется, насколько-то выполнение итерации цикла при этом замедляется. Я бы сказал, что первый вариант универсальнее, а потому до тестов производительности предпочтительнее.

[Shad0wF1rst]

Вообще эту тему я поднял для того что бы был оценен мой изврат. Вот есть функция, которая выполняет то что я говорил выше.

bool function (char *buffer)
{
    for (int i = 0; i < 22; i++) {
        if (buffer[i] != 0) return true;
    }
    return false;
}

тут я думаю объяснять ничего не надо.
Предлагаю заменить ее на такую. Сразу скажу что не пробовал ее еще но все же.

bool function (char *buffer)
{
    int i = 22;
    while (!buffer[i] ^ !i);
    return (i > 0 || buffer[0] != 0);
}

Ну вот если че не понятно могу пояснить)))
Блин тут опечатался строчку while (!buffer[i] ^ !i); заменить на while (!buffer[--i] ^ !i); а то все зациклится)))

[Smitt&Wesson]

В идеале, функция

bool function (char *buffer)
 {
 int i = 22;
 while (!buffer[i] ^ !i);
 return (i > 0 || buffer[0] != 0);
 }

Будет работать быстрее.
Почему? Потому, что не имеет внутреннего счётчика итераций.
Функцию while, можно рассматривать как:

1: if(); 
.........
goto 1;

Тогда как for, рассматривается как

int i;
1:// исполняемые операторы
i=i+1;
if(i<N) goto 1;

[Shad0wF1rst]

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

[Abstraction]

while (!buffer[--i] ^ !i);

Не хорошо. Имеете все шансы уйти за пределы массива.
В любом случае, такого рода оптимизации находятся скорее в ведении оптимизатора. Вы не избавляетесь от проверки, Вы переносите её в другое место. Если извращаться, то мой вариант:

bool IsNotAll0(const char *buffer)
{
for (const char* cur = buffer+22; cur!=buffer; ) if(*--cur != 0) return true;
return false;
}

А теперь в четыре раза быстрее:

bool IsNotAll0(const char *buffer)
{
for (const int* cur = (const int*)buffer+4; cur!=buffer; ) if(*--cur != 0) return true;
return buffer[20]!=0 || buffer[21]!=0;
}

[Shad0wF1rst]

Сообщение от Abstraction

while (!buffer[--i] ^ !i);

Не хорошо. Имеете все шансы уйти за пределы массива.
В любом случае, такого рода оптимизации находятся скорее в ведении оптимизатора. Вы не избавляетесь от проверки, Вы переносите её в другое место. Если извращаться, то мой вариант:

bool IsNotAll0(const char *buffer)
{
for (const char* cur = buffer+22; cur!=buffer; ) if(*--cur != 0) return true;
return false;
}

А теперь в четыре раза быстрее:

bool IsNotAll0(const char *buffer)
{
for (const int* cur = (const int*)buffer+4; cur!=buffer; ) if(*--cur != 0) return true;
return buffer[20]!=0 || buffer[21]!=0;
}

Я кстати думал насчет использования long, да так быстрее, но не так интересно потому что очевидно))). А вот насчет замечания что выйдет за приделы массива я поясню ту запись !buffer[--i] ^ !i;
Предположим когда мы проходим по массиву у нас содержимое его нули и тогда получаем что эта запись имеет следующий вид true ^ false = true;
следующий случай когда все таки встречается в массиве не ноль тогда получаем false ^ flase = flase и успешно выходим из цикла.
И последний случай когда когда все таки все нули в массиве, то есть buffer[0] = 0, тогда получаем true ^ true = false и также успешно выходим из цикла, по этому не вижу никаких выходов за приделы массива.
Может я не все варианты рассмотрел и чего то не учел, буду рад узнать о них)))

[Abstraction]

Может я не все варианты рассмотрел и чего то не учел, буду рад узнать о них)))

Не учли, что ^ - поразрядный оператор. false - это 0, true - это что угодно кроме 0. Поэтому true^true равно, вообще говоря, чему угодно.