技术咨询：在C语言中减少if语句提升效率，后续将迁移至汇编

Nice question—since you’re planning to port this to assembly later, cutting down on conditionals is a fantastic move. Branches can really stall CPU pipelines, especially on embedded or older architectures, so minimizing them will give you a solid efficiency boost. Here are some practical, assembly-friendly strategies to make that happen:

A lot of conditional checks can be rewritten using arithmetic or bitwise tricks that avoid jumps entirely. For example:

• Instead of if (x < 0) x = -x; (absolute value), use bitwise manipulation for 32-bit signed integers:

  x ^= (x >> 31);  // Flip all bits if x is negative
  x -= (x >> 31);  // Subtract -1 (all 1s in two's complement) to get positive value
  

  In assembly, this translates to just a couple of shift, XOR, and subtract instructions—no branches needed.
• For min/max checks like if (a > b) c = a; else c = b;, use arithmetic based on the sign flag:

  c = b + ((a - b) & -(a > b));
  

  This works because -(a > b) will be all 1s if a > b (since a > b evaluates to 1, negated is -1) or all 0s otherwise.

If your conditionals are based on discrete input values (like enums, small integers, or opcodes), replace them with a precomputed lookup table. This turns multiple branch checks into a single memory access.

For example, instead of a switch statement:

switch (opcode) {
    case 0: result = add(a, b); break;
    case 1: result = sub(a, b); break;
    case 2: result = mul(a, b); break;
}

Use a function pointer array (which becomes a jump table in assembly):

typedef int (*OpFunc)(int, int);
OpFunc ops[] = {add, sub, mul};
result = ops[opcode](a, b);

In assembly, you’ll load the opcode as an offset into the jump table and jump directly—no repeated comparisons or conditional jumps.

Look for opportunities to combine related checks into a single conditional, or simplify boolean logic using De Morgan’s laws. For example:

• Instead of two separate checks:

  if (x > 10) error();
  else if (x < 0) error();
  

  Merge them into one: if (x > 10 || x < 0) error();
• Replace if (!(a && b)) with if (!a || !b) (or vice versa) to flatten nested conditionals and reduce branch depth.

Modern CPUs (x86’s CMOV family, ARM’s MOVcc) support conditional moves—instructions that copy a value only if a flag condition is met, no branch required. This is perfect for simple "if-then-else" assignments.

For example, instead of:

if (a > b) {
    max_val = a;
} else {
    max_val = b;
}

In x86 assembly, you’d write:

cmp eax, ebx   ; Compare a (eax) and b (ebx)
cmovg eax, ebx ; Move ebx to eax if eax > ebx (greater than)
mov [max_val], eax

This avoids the pipeline flush that comes with a mispredicted branch, which is a huge win for performance.

If your code is full of state-dependent conditionals (like if (current_state == STATE_A) do_x(); else if (current_state == STATE_B) do_y();), rewrite it as a state machine. State machines map directly to jump tables in assembly, making them extremely efficient—you just update the state register and jump to the next block of code, no messy conditionals.

Quick Notes Before You Dive In #

• Measure first, optimize second: Use a profiler to identify which branches are actually causing bottlenecks. Don’t waste time optimizing rarely executed code.
• Balance readability: Some of these tricks can make your C code harder to read. Add comments explaining the logic so you (or others) can follow along when porting to assembly.
• Assembly-specific tweaks: Once you’re writing assembly, you can go even further—use CPU flags (CF, ZF, SF) directly for calculations, or use bitmasks to replace multiple boolean checks.

内容的提问来源于stack exchange，提问作者TheJet 1