if-else vs Ternary function call performance

Question

In my C++ code, I have to select between two functions that take the same arguments based on a given condition. I could write:

if (condition) 
   return foo(a, b, c);
else
   return bar(a, b, c);

Or:

return (condition? foo : bar)(a, b, c);

But which of these two ways is faster?

EDIT:

I tried to test using this code:

#include <cmath>
#include <chrono>
#include <iostream>

using namespace std;

void foo(float x, float y, int param)
{
    pow(x+y, param);
}

void bar(float x, float y, int param)
{
    pow(x+y, param);
}

int main() {

    const int loops = 1000;

    auto t1 = chrono::high_resolution_clock::now();
    for(int i = 0; i < loops; i++)
        for(int j = 0; j < loops; j++)
            (i==j? foo : bar)(i, j, 2);

    auto t2 = chrono::high_resolution_clock::now();

    for(int i = 0; i < loops; i++)
        for(int j = 0; j < loops; j++)
            if(i==j)
                foo(i, j, 2);
            else
                bar(i, j, 2);

    auto t3 = chrono::high_resolution_clock::now();

    cout << "ternary: " << (chrono::duration_cast<chrono::microseconds>(t2-t1).count()) << "us" << endl;
    cout << "if-else: " << (chrono::duration_cast<chrono::microseconds>(t3-t2).count()) << "us" << endl;
    return 0;
}

With the updated test code I got:

 ternary: 70951us
 if-else: 67962us

Answer 1

Migrated from comments:

Any decent compiler will output the same assembly for both. This is next-level premature optimization and something you shouldn't care about. Pick the one that is most readable and fits into your project style. —Sombrero Chicken

Answer 2

There is no problem with the performance. The compiler can generate the same object code for the both cases.

However there is a difference in applying these constructions.

For the conditional operator there must be deduced the common type of its second and third operands.

For example if you have the following functions

void foo( int, int, int ) {}
int bar( int, int, int ) { return 10; } 

then you can use the if-statement as it is shown in the demonstrative program

#include <iostream>

void foo( int, int, int ) {}
int bar( int, int, int ) { return 10; }         

int main()
{
    int x;
    std::cin >> x;

    if ( x < 10 )
    {
        foo( x, x, x );
    }
    else
    {
        bar( x, x, x );
    }
}

However you may not write as it seems an equivalent code

#include <iostream>

void foo( int, int, int ) {}
int bar( int, int, int ) { return 10; }         

int main()
{
    int x;
    std::cin >> x;

    x < 10 ? foo( x, x, x ) : bar( x, x, x );
}

because the compiler is unable to deduce the common type of the calls foo( x, x, x ) and bar( x, x, x ). The first one has the type void and the second one has the type int.

Of course you could write instead

    x < 10 ? foo( x, x, x ) : ( void )bar( x, x, x );

but sometimes this makes code less readable when compound expressions are used. And moreover sometimes it is even impossible to deduce the common type because there is no explicit or implicit conversion between expressions especially for user-defined types.

Another example. You can write a function to allow the compiler to deduce its return type.

#include <iostream>

constexpr auto factorial( unsigned long long int n )
{
    if ( n < 2 )
    {
        return n;
    }
    else
    {
        return n * factorial( n - 1 );
    }        
}

int main()
{
    int a[factorial( 5 )];

    std::cout << "The array has " << sizeof( a ) / sizeof( *a ) << " elements\n";
}

The program output is

The array has 120 elements

On the other hand, you may not write

#include <iostream>

constexpr auto factorial( unsigned long long int n )
{
    return n < 2 ? n : n * factorial( n - 1 );
}

int main()
{
    int a[factorial( 5 )];

    std::cout << "The array has " << sizeof( a ) / sizeof( *a ) << " elements\n";
}

The compiler is unable to deduce the return type of the function.

So sometimes there is even no choice between whether to use the if-statement or the conditional expression:)