Using intermediate variables for ternary operator (or similar) for better performance?

Generally, no, the compiler won't do it – it can't, actually. Calling f and g could have side effects, and the result of the second call of either f or g might not be the same as in the first call. Imagine something like this:

int f()
{
    static int n = 0;
    return ++n;
}

But there are exceptions proving the rule:

Actually, a compiler is allowed to perform any optimisation it wants to – as long as the optimised code behaves exactly the same (considering any visible effects) as the completely unoptimised one.

So if the compiler can guarantee that omitting the second function call does not suppress any side effects (and only then!), it actually is allowed to optimise the second call away and most likely will do so, too, at higher optimisation levels.

TL;DR: there are functions called min and max...

The compiler may, or may not, perform this optimization for you.

From the compiler point of view, f() > g() ? f() : g() is likely to be:

entry:
    _0 = f();
    _1 = g();
    _cmp = _0 > _1
    if _cmp: goto _greater; else: goto _lesser;

greater:
    _2 = f();
    goto end;

lesser:
    _3 = g();
    goto end;

end:
   phi [greater _2], [lesser _3]

This is called SSA form (Static Single Assignment form), and is used by most optimizers such as LLVM and gcc.

Whether the compiler evaluates f() or g() once or twice will depend on whether:

• f() and g() are either annotated as pure or evaluated to be pure (no side effects, result solely depending on inputs)
• or f() and g() are inlined at the call side
• or...

In general, I would not count on it.

However, all of this does not matter.

There are higher-level functions to do what you want, such as max here:

int a = std::max(f(), g());

guarantees, in C++, that it will only ever evaluate f() and g() once (the order of evaluation is not guaranteed, but both will be evaluated only once, and before the call to max itself).

This is strictly equivalent to:

int _0 = f();
int _1 = g();
int a = std::max(_0, _1);

but of course, much slicker.

"Given sufficient optimization" the compiler might do it, depending on the characteristics of the functions f and g. If the compiler can see the definitions of the functions (so either they're in the same TU they're called from or you're using link time optimization), and can see that they have no side-effects and their results don't depend on any globals, then it can evaluate them only once instead of twice.

If they do have side effects, then you've demanded that they be called twice and so one of them will be evaluated twice.

If they're constexpr, it could call them no times.

For your example, using std::max(f(), g()) is generally more convenient than using intermediate variables. Like any function call it only evaluates each argument once.

Given this code:

int f(int x) {
    return x + 1;
}

int g(int x) {
    return x + 2;
}

int foo(int a, int b) {
    return f(a) > g(b) ? f(a) : g(b);
}

gcc -O0 on my machine produces the following. Even if you can't read it, observe that callq <_Z1fi> occurs twice:

        int foo(int a, int b) {
  1e:   55                      push   %rbp
  1f:   53                      push   %rbx
  20:   48 83 ec 28             sub    $0x28,%rsp
  24:   48 8d ac 24 80 00 00    lea    0x80(%rsp),%rbp
  2b:   00
  2c:   89 4d c0                mov    %ecx,-0x40(%rbp)
  2f:   89 55 c8                mov    %edx,-0x38(%rbp)
                return f(a) > g(b) ? f(a) : g(b);
  32:   8b 4d c0                mov    -0x40(%rbp),%ecx
  35:   e8 c6 ff ff ff          callq  0 <_Z1fi>
  3a:   89 c3                   mov    %eax,%ebx
  3c:   8b 45 c8                mov    -0x38(%rbp),%eax
  3f:   89 c1                   mov    %eax,%ecx
  41:   e8 c9 ff ff ff          callq  f <_Z1gi>
  46:   39 c3                   cmp    %eax,%ebx
  48:   7e 0a                   jle    54 <_Z3fooii+0x36>
  4a:   8b 4d c0                mov    -0x40(%rbp),%ecx
  4d:   e8 ae ff ff ff          callq  0 <_Z1fi>
  52:   eb 0a                   jmp    5e <_Z3fooii+0x40>
  54:   8b 45 c8                mov    -0x38(%rbp),%eax
  57:   89 c1                   mov    %eax,%ecx
  59:   e8 b1 ff ff ff          callq  f <_Z1gi>
        }
  5e:   48 83 c4 28             add    $0x28,%rsp
  62:   5b                      pop    %rbx
  63:   5d                      pop    %rbp
  64:   c3                      retq

whereas gcc -O2 produces:

        int foo(int a, int b) {
                return f(a) > g(b) ? f(a) : g(b);
  20:   8d 42 02                lea    0x2(%rdx),%eax
  23:   83 c1 01                add    $0x1,%ecx
  26:   39 c1                   cmp    %eax,%ecx
  28:   0f 4d c1                cmovge %ecx,%eax
        }
  2b:   c3                      retq

Since it can see the definitions of f and g, the optimizer has had its way with them.