change index between 0 and 1

[Eric Lilja]

Hello, I have a function that has a static array with two elements in
it. When the function is called the first time, it should access
element 0, the second time it should access element 1, the third time
element 0, the fourth element 1 etc. I can do it by having a static
variable holding the index and and if/else-statement but is there a
more clever way that doesn't need the if/else?

[Keith Thompson]

"Eric Lilja" <mi********@gmail.com> writes:

Hello, I have a function that has a static array with two elements in
it. When the function is called the first time, it should access
element 0, the second time it should access element 1, the third time
element 0, the fourth element 1 etc. I can do it by having a static
variable holding the index and and if/else-statement but is there a
more clever way that doesn't need the if/else?

The obvious way to do this would be to pass the index as a parameter,
but I presume you to do this independently of the caller.

Here's one approach:

void func(whatever)
{
static int index = 0;
static element_type arr[2];
/* ... code referring to arr[index] ... */
index = 1 - index;
}

For sizes other than 2, something like this:

index = (index + 1) % ARRAY_SIZE;

is more general.

--
Keith Thompson (The_Other_Keith) ks***@mib.org <http://www.ghoti.net/~kst>
San Diego Supercomputer Center <*> <http://users.sdsc.edu/~kst>
We must do something. This is something. Therefore, we must do this.

[Ian Collins]

Eric Lilja wrote:

Hello, I have a function that has a static array with two elements in
it. When the function is called the first time, it should access
element 0, the second time it should access element 1, the third time
element 0, the fourth element 1 etc. I can do it by having a static
variable holding the index and and if/else-statement but is there a
more clever way that doesn't need the if/else?

static unsigned index = 1;

return array[index^=1];

--
Ian Collins.

[pete]

Eric Lilja wrote:

Hello, I have a function that has a static array with two elements in
it. When the function is called the first time, it should access
element 0, the second time it should access element 1, the third time
element 0, the fourth element 1 etc. I can do it by having a static
variable holding the index and and if/else-statement but is there a
more clever way that doesn't need the if/else?

/* BEGIN new.c */

#include <stdio.h>

void sequence(size_t first, size_t second);

int main(void)
{
unsigned flip;
size_t index;

puts("/* BEGIN new.c output */\n");
for (index = 0; index != 5; ++index) {
sequence(flip++ & 1, index);
sequence(flip++ & 1, index);
}
puts("\n\n/* END new.c output */");
return 0;
}

void sequence(size_t first, size_t second)
{
int array[][5] = {0,2,4,6,8,1,3,5,7,9};

putchar('0' + array[first][second]);
}

/* END new.c */

--
pete

[pete]

pete wrote:

unsigned flip;

unsigned flip = 0;

That should have been initialized.

--
pete

[Jack Klein]

On 14 Feb 2006 17:20:25 -0800, "Eric Lilja" <mi********@gmail.com>
wrote in comp.lang.c:

Hello, I have a function that has a static array with two elements in
it. When the function is called the first time, it should access
element 0, the second time it should access element 1, the third time
element 0, the fourth element 1 etc. I can do it by having a static
variable holding the index and and if/else-statement but is there a
more clever way that doesn't need the if/else?

static int index = 1; /* you'll see in a minute */

int values [2] = { first_value, second_value };

int get_value(void)
{
index = !index;
return values [index];
}

Initializing to 1 and performing the logical negation before use
ensures two things. First, you get the 0 element of the array the
first time, and second that the value you use for the subscript is
always 0 or 1, never out of range.

--
Jack Klein
Home: http://JK-Technology.Com
FAQs for
comp.lang.c http://c-faq.com/
comp.lang.c++ http://www.parashift.com/c++-faq-lite/
alt.comp.lang.learn.c-c++
http://www.contrib.andrew.cmu.edu/~a...FAQ-acllc.html

[Martin Ambuhl]

Eric Lilja wrote:

Hello, I have a function that has a static array with two elements in
it. When the function is called the first time, it should access
element 0, the second time it should access element 1, the third time
element 0, the fourth element 1 etc. I can do it by having a static
variable holding the index and and if/else-statement but is there a
more clever way that doesn't need the if/else?

void function(void)
{
static int index;
index = 1 - index;
}

[Neil]

Eric Lilja wrote:

Hello, I have a function that has a static array with two elements in
it. When the function is called the first time, it should access
element 0, the second time it should access element 1, the third time
element 0, the fourth element 1 etc. I can do it by having a static
variable holding the index and and if/else-statement but is there a
more clever way that doesn't need the if/else?

how about:

index = (++index % 2); // works for powers of 2
return array[index];

[Ben Pfaff]

Neil <Ne*******@worldnet.att.net> writes:

index = (++index % 2); // works for powers of 2

If "works" means "invokes undefined behavior", then you're
correct ;-)

Your suggestion is undefined because it modifies the value of
`index' twice between sequence points.

Here is a working suggestion in the same pattern as yours:
index = (index + 1) % 2;
--
int main(void){char p[]="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuv wxyz.\
\n",*q="kl BIcNBFr.NKEzjwCIxNJC";int i=sizeof p/2;char *strchr();int putchar(\
);while(*q){i+=strchr(p,*q++)-p;if(i>=(int)sizeof p)i-=sizeof p-1;putchar(p[i]\
);}return 0;}

[Eric Lilja]

Eric Lilja wrote:

Hello, I have a function that has a static array with two elements in
it. When the function is called the first time, it should access
element 0, the second time it should access element 1, the third time
element 0, the fourth element 1 etc. I can do it by having a static
variable holding the index and and if/else-statement but is there a
more clever way that doesn't need the if/else?

Thanks for the replies, everyone, I actually had a ++index %
2-statement
(index was initialized to 0), but I had forgot to make it static so I
always ended up using the element with index 0, heh. Now to a question
to a related problem, why am I getting the following warnings and how
do I fix
them?

typedef void (* fptr)();
fptr * array[] = {idle_callback, NULL}; /* This is the actual
two-element array. */
Warning for line above:
simple_1-5.c:24: warning: initialization from incompatible pointer type
idle_callback is declared as: static void idle_callback(void);

glutIdleFunc(array[++index % 2]);
Warning for line above:
simple_1-5.c:32: warning: passing arg 1 of `glutIdleFunc' from
incompatible pointer type

They seem harmless because my program works as expected on my system at
least, but I'd like to fix them anyway.

[Banfa]

Eric Lilja wrote:[color=blue]
Now to a question
to a related problem, why am I getting the following warnings and how
do I fix
them?

typedef void (* fptr)();
fptr * array[] = {idle_callback, NULL}; /* This is the actual
two-element array. */
Warning for line above:
simple_1-5.c:24: warning: initialization from incompatible pointer type
idle_callback is declared as: static void idle_callback(void);

glutIdleFunc(array[++index % 2]);
Warning for line above:
simple_1-5.c:32: warning: passing arg 1 of `glutIdleFunc' from
incompatible pointer type

They seem harmless because my program works as expected on my system at
least, but I'd like to fix them anyway.

It's because you have 1 * too many in

typedef void (* fptr)();
fptr * array[] = {idle_callback, NULL};
 

The type fptr is a defined as a pointer to a function and array is declared are an array of pointers to type fptr. Therefore the type of a single element of array is pointer to pointer to function.

Try declaring array as

fptr array[] = {idle_callback, NULL};
 

[Antonio Contreras]

Eric Lilja wrote:

Eric Lilja wrote:

Hello, I have a function that has a static array with two elements in
it. When the function is called the first time, it should access
element 0, the second time it should access element 1, the third time
element 0, the fourth element 1 etc. I can do it by having a static
variable holding the index and and if/else-statement but is there a
more clever way that doesn't need the if/else?

Thanks for the replies, everyone, I actually had a ++index %
2-statement
(index was initialized to 0), but I had forgot to make it static so I
always ended up using the element with index 0, heh. Now to a question
to a related problem, why am I getting the following warnings and how
do I fix
them?

typedef void (* fptr)();
fptr * array[] = {idle_callback, NULL}; /* This is the actual
two-element array. */
Warning for line above:
simple_1-5.c:24: warning: initialization from incompatible pointer type
idle_callback is declared as: static void idle_callback(void);

glutIdleFunc(array[++index % 2]);
Warning for line above:
simple_1-5.c:32: warning: passing arg 1 of `glutIdleFunc' from
incompatible pointer type

They seem harmless because my program works as expected on my system at
least, but I'd like to fix them anyway.

The warning description is quite explicit. You are initializing a
function pointer array element with a pointer of a different type. Look
at the declarations. fptr is declared as:

typedef void (* fptr) ();

This a pointer to a function returning void and with unspecified
parameters.

In the warning message says that idle_callback is declared as:

static void idle_callback (void);

This is a pointer to a function returning void and with no parameters.
Those types are not the same. The easiest way to remove those warnings
is to redeclare fptr as:

typedef void (* fptr) (void);

[Eric Lilja]

Antonio Contreras wrote:

Eric Lilja wrote:

Eric Lilja wrote:

Hello, I have a function that has a static array with two elements in
it. When the function is called the first time, it should access
element 0, the second time it should access element 1, the third time
element 0, the fourth element 1 etc. I can do it by having a static
variable holding the index and and if/else-statement but is there a
more clever way that doesn't need the if/else?

Thanks for the replies, everyone, I actually had a ++index %
2-statement
(index was initialized to 0), but I had forgot to make it static so I
always ended up using the element with index 0, heh. Now to a question
to a related problem, why am I getting the following warnings and how
do I fix
them?

typedef void (* fptr)();
fptr * array[] = {idle_callback, NULL}; /* This is the actual
two-element array. */
Warning for line above:
simple_1-5.c:24: warning: initialization from incompatible pointer type
idle_callback is declared as: static void idle_callback(void);

glutIdleFunc(array[++index % 2]);
Warning for line above:
simple_1-5.c:32: warning: passing arg 1 of `glutIdleFunc' from
incompatible pointer type

They seem harmless because my program works as expected on my system at
least, but I'd like to fix them anyway.

The warning description is quite explicit. You are initializing a
function pointer array element with a pointer of a different type. Look
at the declarations. fptr is declared as:

typedef void (* fptr) ();

This a pointer to a function returning void and with unspecified
parameters.

In the warning message says that idle_callback is declared as:

static void idle_callback (void);

This is a pointer to a function returning void and with no parameters.
Those types are not the same. The easiest way to remove those warnings
is to redeclare fptr as:

typedef void (* fptr) (void);

No, that wasn't it. That yields the same warnings. The error turned out
to be:
fptr * array[] = {idle_callback, NULL};
this should be
fptr array[] = {idle_callback, NULL};

[stathis gotsis]

"Eric Lilja" <mi********@gmail.com> wrote in message
news:11**********************@g43g2000cwa.googlegr oups.com...

Eric Lilja wrote:

Hello, I have a function that has a static array with two elements in
it. When the function is called the first time, it should access
element 0, the second time it should access element 1, the third time
element 0, the fourth element 1 etc. I can do it by having a static
variable holding the index and and if/else-statement but is there a
more clever way that doesn't need the if/else?

Thanks for the replies, everyone, I actually had a ++index %
2-statement
(index was initialized to 0), but I had forgot to make it static so I
always ended up using the element with index 0, heh. Now to a question
to a related problem, why am I getting the following warnings and how
do I fix
them?

typedef void (* fptr)();
fptr * array[] = {idle_callback, NULL}; /* This is the actual
two-element array. */
Warning for line above:
simple_1-5.c:24: warning: initialization from incompatible pointer type
idle_callback is declared as: static void idle_callback(void);

glutIdleFunc(array[++index % 2]);
Warning for line above:
simple_1-5.c:32: warning: passing arg 1 of `glutIdleFunc' from
incompatible pointer type

They seem harmless because my program works as expected on my system at
least, but I'd like to fix them anyway.

Try this change:
fptr array[]={idle_callback,NULL};

[Antonio Contreras]

Eric Lilja wrote:

Antonio Contreras wrote:

Eric Lilja wrote:

Eric Lilja wrote:
> Hello, I have a function that has a static array with two elements in
> it. When the function is called the first time, it should access
> element 0, the second time it should access element 1, the third time
> element 0, the fourth element 1 etc. I can do it by having a static
> variable holding the index and and if/else-statement but is there a
> more clever way that doesn't need the if/else?

Thanks for the replies, everyone, I actually had a ++index %
2-statement
(index was initialized to 0), but I had forgot to make it static so I
always ended up using the element with index 0, heh. Now to a question
to a related problem, why am I getting the following warnings and how
do I fix
them?

typedef void (* fptr)();
fptr * array[] = {idle_callback, NULL}; /* This is the actual
two-element array. */
Warning for line above:
simple_1-5.c:24: warning: initialization from incompatible pointer type
idle_callback is declared as: static void idle_callback(void);

glutIdleFunc(array[++index % 2]);
Warning for line above:
simple_1-5.c:32: warning: passing arg 1 of `glutIdleFunc' from
incompatible pointer type

They seem harmless because my program works as expected on my system at
least, but I'd like to fix them anyway.

The warning description is quite explicit. You are initializing a
function pointer array element with a pointer of a different type. Look
at the declarations. fptr is declared as:

typedef void (* fptr) ();

This a pointer to a function returning void and with unspecified
parameters.

In the warning message says that idle_callback is declared as:

static void idle_callback (void);

This is a pointer to a function returning void and with no parameters.
Those types are not the same. The easiest way to remove those warnings
is to redeclare fptr as:

typedef void (* fptr) (void);

No, that wasn't it. That yields the same warnings. The error turned out
to be:
fptr * array[] = {idle_callback, NULL};
this should be
fptr array[] = {idle_callback, NULL};

Yup, missed that little asterisk. However, it is always a good idea
beeing explicit about the parameters when you declare function
pointers. That way the compiler can check argument types.

[Chris McDonald]

>> > > Eric Lilja wrote:

> > > Hello, I have a function that has a static array with two elements in
> > > it. When the function is called the first time, it should access
> > > element 0, the second time it should access element 1, the third time
> > > element 0, the fourth element 1 etc. I can do it by having a static
> > > variable holding the index and and if/else-statement but is there a
> > > more clever way that doesn't need the if/else?
> >
> > Thanks for the replies, everyone, I actually had a ++index %
> > 2-statement

Sorry, I can no longer find earlier articles in this thread, but what
about the traditional:

static int index = 0;
......
index = 1 - index;

--
Chris.

[ena8t8si]

Eric Lilja wrote:

Hello, I have a function that has a static array with two elements in
it. When the function is called the first time, it should access
element 0, the second time it should access element 1, the third time
element 0, the fourth element 1 etc. I can do it by having a static
variable holding the index and and if/else-statement but is there a
more clever way that doesn't need the if/else?

int alternate(void)
{
static int v[] = {411,219};
static _Bool vi;

return v[vi--];
}

[Martin Ambuhl]

Chris McDonald wrote:

Sorry, I can no longer find earlier articles in this thread, but what
about the traditional:

static int index = 0;
......
index = 1 - index;

When I suggested this in
<dr*****************@newsread1.news.atl.earthlink. net> (11 hours before
yours) it was completely ignored, in favor of discussion of the sloppy
and obfuscated mechanism you responded to.

[Neil]

Ben Pfaff wrote:

Neil <Ne*******@worldnet.att.net> writes:

index = (++index % 2); // works for powers of 2

If "works" means "invokes undefined behavior", then you're
correct ;-)

Your suggestion is undefined because it modifies the value of
`index' twice between sequence points.

Here is a working suggestion in the same pattern as yours:
index = (index + 1) % 2;

Thanks
Sorry about the poor execution.

[Joe Wright]

Neil wrote:

Ben Pfaff wrote:

Neil <Ne*******@worldnet.att.net> writes:

index = (++index % 2); // works for powers of 2

If "works" means "invokes undefined behavior", then you're
correct ;-)

Your suggestion is undefined because it modifies the value of
`index' twice between sequence points.

Here is a working suggestion in the same pattern as yours:
index = (index + 1) % 2;

Thanks
Sorry about the poor execution.

Too complicated. Assume a function to return alternatively 0, 1 then 0
etc. It might look like ..

int inc(void) {
static int i;
return i = i++ & 1;
}

--
Joe Wright
"Everything should be made as simple as possible, but not simpler."
--- Albert Einstein ---

[pete]

Joe Wright wrote:

Neil wrote:

Ben Pfaff wrote:

Neil <Ne*******@worldnet.att.net> writes:

index = (++index % 2); // works for powers of 2
If "works" means "invokes undefined behavior", then you're
correct ;-)

Your suggestion is undefined because it modifies the value of
`index' twice between sequence points.

Here is a working suggestion in the same pattern as yours:
index = (index + 1) % 2;

Thanks
Sorry about the poor execution.

Too complicated. Assume a function to return alternatively 0, 1 then 0
etc. It might look like ..

int inc(void) {
static int i;
return i = i++ & 1;
}

That return statement has undefined behavior.

unsigned inc(void)
{
static unsigned i;

return i++ & 1;
}

--
pete

[Joe Wright]

pete wrote:

Joe Wright wrote:

Neil wrote:

Ben Pfaff wrote:
Neil <Ne*******@worldnet.att.net> writes:
>index = (++index % 2); // works for powers of 2
If "works" means "invokes undefined behavior", then you're
correct ;-)

Your suggestion is undefined because it modifies the value of
`index' twice between sequence points.

Here is a working suggestion in the same pattern as yours:
index = (index + 1) % 2;

Thanks
Sorry about the poor execution.

Too complicated. Assume a function to return alternatively 0, 1 then 0
etc. It might look like ..

int inc(void) {
static int i;
return i = i++ & 1;
}

That return statement has undefined behavior.

unsigned inc(void)
{
static unsigned i;

return i++ & 1;
}

Bless you my son. The assignment was questionable perhaps. But why
unsigned instead of int? The variable i is initialized to 0 by the
compiler and has no chance of exceeding 2. Signedness is not an issue
here. What's the problem?

--
Joe Wright
"Everything should be made as simple as possible, but not simpler."
--- Albert Einstein ---

[Chris McDonald]

Joe Wright <jo********@comcast.net> writes:

unsigned inc(void)
{
static unsigned i;

return i++ & 1;
}

Bless you my son. The assignment was questionable perhaps. But why
unsigned instead of int? The variable i is initialized to 0 by the
compiler and has no chance of exceeding 2. Signedness is not an issue
here. What's the problem?

But why, oh why, are people proposing these fancy
power-of-2-based-modulo-or-masking-solutions over the oft offered:

i = 1 - i;
?

--
Chris.

[Antonio Contreras]

Chris McDonald wrote:

Joe Wright <jo********@comcast.net> writes:

unsigned inc(void)
{
static unsigned i;

return i++ & 1;
}
Bless you my son. The assignment was questionable perhaps. But why
unsigned instead of int? The variable i is initialized to 0 by the
compiler and has no chance of exceeding 2. Signedness is not an issue
here. What's the problem?

int will cause undefined behaviour when it overflows, unsigned won't.
But why, oh why, are people proposing these fancy
power-of-2-based-modulo-or-masking-solutions over the oft offered:

i = 1 - i;
?

Because beauty is in the eye of the beholder and there may be people
who happen to like other solutions better.

The modulus solution below has the clear advantage of being scalable to
larger array sizes.

#define ARRAY_SIZE 2

int index (void) {
static int i = 0;
return i = (i + 1) % ARRAY_SIZE;
}

If I were absolutely sure that I'll never need a larger array I'd go
with another offered solution:

int index (void) {
static int i = 1;
return i = !i;
}

which in turn has the advantage that if i somehow (wild pointers,
buffer overflow...) gets a value different than 0 or 1, it will return
to sequence in the next call (the damage may have been done by now, but
that's another matter).

[Old Wolf]

Joe Wright wrote:

pete wrote:

Joe Wright wrote:

Ben Pfaff wrote:
>Neil wrote:
>>
>>index = (++index % 2); // works for powers of 2
>
>Your suggestion is undefined because it modifies the value of
>`index' twice between sequence points.

int inc(void) {
static int i;
return i = i++ & 1;
}

That return statement has undefined behavior.

Bless you my son. The assignment was questionable perhaps.
What's the problem?

Your suggestion is undefined because it modifies the value of
`i' twice between sequence points.

[Chris McDonald]

"Antonio Contreras" <an*****@gmail.com> writes:

If I were absolutely sure that I'll never need a larger array I'd go
with another offered solution: int index (void) {
static int i = 1;
return i = !i;
} which in turn has the advantage that if i somehow (wild pointers,
buffer overflow...) gets a value different than 0 or 1, it will return
to sequence in the next call (the damage may have been done by now, but
that's another matter).

Even better, and meets the OP's requirements; thanks!

--
Chris.

[Keith Thompson]

Joe Wright <jo********@comcast.net> writes:

pete wrote:

Joe Wright wrote: [...]

Too complicated. Assume a function to return alternatively 0, 1 then 0
etc. It might look like ..

int inc(void) {
static int i;
return i = i++ & 1;
}

That return statement has undefined behavior.

unsigned inc(void)
{
static unsigned i;

return i++ & 1;
}

Bless you my son. The assignment was questionable perhaps. But why
unsigned instead of int? The variable i is initialized to 0 by the
compiler and has no chance of exceeding 2. Signedness is not an issue
here. What's the problem?

In pete's solution, i is incremented every time the function is
called. The value returned by the function will always be either 0 or
1, but the value of i will increase without bound. There could be two
reasons to make it unsigned: bitwise operations on signed types are
generally to be avoided, and unsigned int has defined behavior on
overflow.

But allowing i to increase without bound is a kludge. It's much
simpler to keep i itself in the range 0..1. Something like
i = 1 - i;
return i;
is longer but *much* simpler.

--
Keith Thompson (The_Other_Keith) ks***@mib.org <http://www.ghoti.net/~kst>
San Diego Supercomputer Center <*> <http://users.sdsc.edu/~kst>
We must do something. This is something. Therefore, we must do this.

[pete]

Joe Wright wrote:

pete wrote:

Joe Wright wrote:

Neil wrote:

Ben Pfaff wrote:
>Neil <Ne*******@worldnet.att.net> writes:
>
>
>>index = (++index % 2); // works for powers of 2
>
>
>If "works" means "invokes undefined behavior", then you're
>correct ;-)
>
>Your suggestion is undefined because it modifies the value of
>`index' twice between sequence points.
>
>Here is a working suggestion in the same pattern as yours:
> index = (index + 1) % 2;

Thanks
Sorry about the poor execution.

Too complicated. Assume a function to return alternatively 0, 1 then 0
etc. It might look like ..

int inc(void) {
static int i;
return i = i++ & 1;
}

That return statement has undefined behavior.

unsigned inc(void)
{
static unsigned i;

return i++ & 1;
}

Bless you my son. The assignment was questionable perhaps. But why
unsigned instead of int?

I'm letting the i variable roll over at UINT_MAX.
The variable i is initialized to 0 by the
compiler and has no chance of exceeding 2. Signedness is not an issue
here. What's the problem?

Like "Old Wolf" said:
"modifies the value of `i' twice between sequence points"

i = i++; /* No good */

Assignment is not a sequence point.

--
pete

[Ian Collins]

Chris McDonald wrote:

But why, oh why, are people proposing these fancy
power-of-2-based-modulo-or-masking-solutions over the oft offered:

i = 1 - i;
?

Or even i^=1, which should be very efficient.

--
Ian Collins.

[Keith Thompson]

Ian Collins <ia******@hotmail.com> writes:

Chris McDonald wrote:

But why, oh why, are people proposing these fancy
power-of-2-based-modulo-or-masking-solutions over the oft offered:
i = 1 - i;
?

Or even i^=1, which should be very efficient.

Any improvement in efficiency is unlikely to be worth the loss of
clarity. Remember the Rules of Optimization.

--
Keith Thompson (The_Other_Keith) ks***@mib.org <http://www.ghoti.net/~kst>
San Diego Supercomputer Center <*> <http://users.sdsc.edu/~kst>
We must do something. This is something. Therefore, we must do this.

[Ian Collins]

Keith Thompson wrote:

Ian Collins <ia******@hotmail.com> writes:

Chris McDonald wrote:

But why, oh why, are people proposing these fancy
power-of-2-based-modulo-or-masking-solutions over the oft offered:
i = 1 - i;
?

Or even i^=1, which should be very efficient.

Any improvement in efficiency is unlikely to be worth the loss of
clarity. Remember the Rules of Optimization.

Clarity is in the eye of the beholder!

--
Ian Collins.