多个 If 语句与使用逻辑运算符评估条件的单个语句

Question

I am writing a function that checks several conditions before actually executing its task. This is done by a number of if statements. Like so:

bool foo()
{
    if(invalid())
        return false;
    if(dont_execute())
        return false;
    // .. etc
    // Actual execution here
    return true;
}

In this function is there any benefits by changing the multiple conditions to :

bool foo()
{
    if(invalid() || dont_execute() /* || .. etc */)
        return false;
    // Actual execution here
    return true;
}

I feel that the first style is more readable. What I want to know is, if there is any performance impact in using multiple if statements rather than combining using logical operators.

Answer 1

No there is no performance impact. If we compare the assembly of both functions we can see that it is identical for both functions.

Example:

bool f1();
bool f2();

bool combined()
{
    if (f1() || f2())
        return false;

    return true;
}

bool separate()
{
    if (f1())
        return false;

    if (f2())
        return false;

    return true;
}

And here the assembly:

combined():
        sub     rsp, 8
        call    f1()
        mov     r8d, eax
        xor     eax, eax
        test    r8b, r8b
        jne     .L1
        call    f2()
        xor     eax, 1
.L1:
        add     rsp, 8
        ret

separate():
        sub     rsp, 8
        call    f1()
        mov     r8d, eax
        xor     eax, eax
        test    r8b, r8b
        jne     .L7
        call    f2()
        xor     eax, 1
.L7:
        add     rsp, 8
        ret

Answer 2

Using the test case

bool invalid();

bool dont_execute();

void execute();

bool foo()
{
    if(invalid())
        return false;
    if(dont_execute())
        return false;
    execute();
    return true;
}

bool foo2()
{
    if(invalid() || dont_execute() /* || .. etc */)
        return false;
    execute();
    return true;
}

you can see that both foo and foo2 are compiled to the exact same assembly by both GCC 9.2 and Clang 9 with -O2 optimization flags, see godbolt . For example GCC's output is

foo():
        sub     rsp, 8
        call    invalid()
        test    al, al
        je      .L2
.L4:
        xor     eax, eax
        add     rsp, 8
        ret
.L2:
        call    dont_execute()
        test    al, al
        jne     .L4
        call    execute()
        mov     eax, 1
        add     rsp, 8
        ret
foo2():
        sub     rsp, 8
        call    invalid()
        test    al, al
        je      .L8
.L10:
        xor     eax, eax
        add     rsp, 8
        ret
.L8:
        call    dont_execute()
        test    al, al
        jne     .L10
        call    execute()
        mov     eax, 1
        add     rsp, 8
        ret

While this does not mean that there will never be a difference, at least the compilers don't think they need to do anything different in the two cases, even if they don't know what the functions called do.

So I suggest you don't worry about performance, but go with what you consider more readable.