Standard idiom for executing a while loop one more time - c

Question

Is there a pattern in C to execute a while loop one more time.
Currently I'm using
while(condition) {
condition = process();
// process() could be multiple lines instead of a function call
// so while(process());process(); is not an option
}
process();
which is horrible if process is of multiple lines and not a single function call.
The alternative is
bool run_once_more = 1;
while(condition || run_once_more) {
if (!condition) {
run_once_more = 0;
}
condition = process();
condition = condition && run_once_more;
}
Is there a better way?
Note: A do while loop is not a solution as it is equivalent to
process();
while(condition){condition=process();}
I want
while(condition){condition=process();}
process();
Per requests, a bit more specific code.
I want to fill buffer from another_buffer and get
(indexof(next_set_bit) + 1) into MSB while maintaining both masks and pointers.
uint16t buffer;
...
while((buffer & (1 << (8*sizeof(buffer) - 1))) == 0) { // get msb as 1
buffer <<= 1;
// fill LSB from another buffer
buffer |= (uint16_t) (other_buffer[i] & other_buffer_mask);
// maintain other_buffer pointers and masks
other_buffer_mask >>= 1;
if(!(other_buffer_mask)) {
other_buffer_mask = (1 << 8*sizeof(other_buffer[0]) -1)
++i;
}
}
// Throw away the set MSB
buffer <<= 1;
buffer |= (uint16_t) (other_buffer[i] & other_buffer_mask);
other_buffer_mask >>= 1;
if(!(other_buffer_mask)) {
other_buffer_mask = (1 << 8*sizeof(other_buffer[0]) -1)
++i;
}
use_this_buffer(buffer);

Answer 1

Because it's not a very typical thing to do, it's unlikely that there is a standard idiom for doing this. However, I'd write the code like this:
for (bool last = 0; condition || last; last = !(condition || last)) {
condition = process();
}
The loop will execute as long as condition is true and then one more time, or zero times if condition is false when the loop begins. I interpret your question as meaning that that is the desired behavior. If not, and you always want the loop to execute at least once, then do...while is the idiom you seek.

Answer 2

What about this:
int done, condition = 1;
for (;;) {
...
done = !condition;
condition = process();
if (done) break;
...
}
I am not suggesting this is a standard idiom, just an ad hoc hack.

Answer 3

I'd use this:
bool done = false;
do {
if (!condition) done = true;
condition = process();
} while (!done);
A much less readable hack, assuming condition is not predefined:
for (bool condition=true, done=false;
!done && (condition || done = true);
) {
condition = process();
}

Answer 4

I've had this same issue and my solution is:
Only if you know for sure you want to run process() at least once:
while(1){
process();
if(!condition()) break;
/*The loop breaks before bad things happen*/
things_you_want_to_happen_only_while_condition_is_true();
}
If you are not sure:
if(condition()){ /*Same as before, but it checks first*/
while(1){
process();
if(!condition()) break;
/*The loop breaks before bad things happen*/
things_you_want_to_happen_only_while_condition_is_true();
}
}
For example:
/*A pointer that goes over the string T from right to left.
It prints "Yes" when pointing at the character 'O' and "No" when not*/
char T[] = {'O', 'V', 'E', 'R', 'F', 'L', 'O', 'W', 0};
char *P = &T[strlen(T)-1]; /*We want the pointer to start at the last character of T*/
while(1){
if(*P=='O') printf("Yes\n");
else printf("No\n");
if(P==&T[0]) break; /*When it reaches the beginning of T, it stops*/
/*We only want the pointer to go further back if it is not in the beginning of T.
That's because we don't know what's before in the memory.*/
P--;
}

Answer 5

Your code is way more advanced than my level, but I came to this question as I had a similar difficulty on a problem set (I wanted the function to execute one last time) and I solved it like this:
define check_value as type_required;
while (check_value)
{
check_value = additional_output_from_process;
condition = process();
}
Would something like that work? In my problem I'm just taking a modulus so I can just run the process twice, system overhead really isn't a consideration.
This works in my example but it might just be a specific use case? I don't know, I'm literally only 6 months into coding.
I think what I'm trying to say is: introduce an additional value, and set the logical test so that the function output (operation) additional value = true. Then set the value of the additional value before you evalutate the function. The result function output (operation) additional value then will only be set to true after the loop has already run again.