Validate parameter for 0 or 1

Question

I have a parameter num of int type, where the user can give it one of two values: 0 or 1.
I can check it using the obvious:

if (num < 0 || num > 1)
    print("The parameter value is incorrect.\n");

But I was wondering if there was a better (faster? less code?) to do this?

EDIT
This is some data flow code, so performance is of the essence. I am looking for a faster way to run this check.

Thanks

Answer 1

I'd go on clearness instead of less characters:

if (num != 0 && num != 1){
    print("The parameter value is incorrect.\n");
}

when it's 2 AM and you're debugging a program, the last thing you want is to over-think about ranges and bitwise operations.

Answer 2

Clear code over (naive) micro-optimizations

You are essentially making wrong assumptions about actual compiler's behavior. In both cases, that is:

if (num < 0 || num > 1) { ...

and

if (num != 0 && num != 1) { ...

an optimizing compiler will reduce it anyway into shortest form. You may see that, both generate the same assembly, that might look as (x86 platform):

cmp    $0x1,%eax
jbe    1e <foo+0x1e> # jump if below or equal

This is already fast enough, as cmp instruction on all major architectures has latency of one cycle.

The bottom line is to choose whatever code, that makes your intent clear for you, future maintainers and let the compiler do its job. Just make sure, that you set it with proper optimization level (e.g. -O2 or better).

---

Aid branch prediction

However, if performance is really crucial here (and you profiled it as so, don't you?), then you could think about another kind of optimization, that is at branch prediction level (assuming that your CPU has support for it). The GCC has __builtin_expect intrinsic, that allows to hint compiler, that in most cases branch will be taken or not.

You may use __builtin_expect to provide the compiler with branch prediction information. In general, you should prefer to use actual profile feedback for this (-fprofile-arcs), as programmers are notoriously bad at predicting how their programs actually perform. However, there are applications in which this data is hard to collect.

For instance, if you are confident, that function takes 0 or 1 in aproximately 99% number of cases, then you could write it as:

#define unlikely(x) __builtin_expect((x), 0)

if (unlikely(num != 0 && num != 1)) { ...

Answer 3

if (!!num == num)
{
   /* value is either a zero or 1 */
}

!! will change other values into 0 or 1, so if you tried to pass 5:

if (1 == 5) // FALSE:

Answer 4

you can use shift operator

if(num>>1) print("The parameter value is incorrect.\n");

Answer 5

Since the only bit that can be lit up is the first one, checking the rest of the bits are switched off does the trick.

Also, since it's only 1, the negative of it is (in c syntax): ~1.

So:

if (num & ~1)
    print("The parameter value is incorrect.\n");

Answer 6

There are a lot of ways of doing that. I think that the short ways are not always the right one. Think that there are times when probably you need to inform the user about his input, not just saying "The parameter value is incorrect". Me, I have my own Function, try this:

#include<stdio.h>

int checkInput(int min, int max);

int main(void){
    int number = checkInput(0,1);

    printf("\nYour number is\t%d\n",number);

    return 0;
}

int checkInput(int min, int max){
    int option,check;
    char c;

    do{
        printf("Please type a number beetwen %d and %d:\t",min,max);

        if(scanf("%d%c",&option,&c) == 0 || c != '\n'){
            while((check = getchar()) != EOF && check != '\n');
            printf("\tI sayed a Number please\n\n");
        }else if(option < min || option > max){
            printf("\tThe number has to be beetwen %d and %d\n\n",min,max);
        }else{
            break;
        }
    }while(1);

    return option;
}

Output:

Please type a number beetwen 0 and 1: 0k
    I sayed a Number please

Please type a number beetwen 0 and 1:   1j
    I sayed a Number please

Please type a number beetwen 0 and 1:   8
    The number has to be beetwen 0 and 1

Please type a number beetwen 0 and 1:   1

Your number is  1

Answer 7

Agree if (num < 0 || num > 1) { ... is the way to go

Thought I'd add a code golf-like answer

if (num > 1u) { ...

This converts int num into an unsigned before comparing to 1u.

A weakness to this approach is if num is made to a wider signed type than unsigned. In that case code could "lull" us into more obscurity

if (num > 1ull) { ...

In the end, using (num < 0 || num > 1) will

1. Generate the fastest code or

2. Generate poor code and OP really should be looking at a better compiler for overall performance improvement than such a small code optimization.