The Conditional Operator `?:` in C++

Trace the state

1. The condition x > y is evaluated.
2. If the condition is true, the expression produces 2.
3. If the condition is false, the expression produces 0.
4. The produced value is assigned to x.
5. The operator chooses between values; it does not merely produce true or false.

Selection task

For one mini-exercise item, state whether the conditional operator improves or harms readability and why.

Statement form

The branch exists only to assign one of two values.

int x = 1;
int y = 2;

if (x > y) {
    x = 2;
} else {
    x = 0;
}

Expression form

The same value choice can be written directly.

x = (x > y ? 2 : 0);

Applied task

Explain why the conditional operator is appropriate here, and name one situation where it would not be appropriate.

Conditional expression in output and arguments

The value selected by ?: is substituted into the surrounding expression.

#include <iostream>

int main() {
    int x = 3, y = 7;

    std::cout << (x > y ? x : y) << " is greater.\n";

    auto choose = [](int a, int b) { return a + b; };
    int z = choose((x > y ? x : y), 10);

    const char* tag = (x % 2 == 0 ? "even" : "odd");
}

Applied task

Trace the value passed as the first argument to choose when x is 3 and y is 7.

Assigning through the selected lvalue

The assignment targets a when cond is true, otherwise b.

int a = 1, b = 2;
bool cond = true;

(cond ? a : b) = 42; // assigns to 'a' if cond, else to 'b'

Mixed arm types can surprise

0 and 1.5 are compatible, but the result type is double.

auto v = (flag ? 0 : 1.5); // v is double

Applied task

For each conditional expression, state the resulting type and whether the expression is an lvalue.

Parentheses clarify stream output

The stream receives the selected string.

std::cout << (ok ? "yes" : "no") << '\n';

Right-associative nesting

This parses from the right, but a named variable or switch is usually clearer.

auto label = a ? "A" : c ? "C" : "other";
// parses as: a ? "A" : (c ? "C" : "other")

Applied task

Rewrite the nested example with ordinary if statements or named predicates, then compare readability.

Unclear mixed types

This compiles, but the resulting type may not be what a novice expects.

auto v = (flag ? 0 : 1.5); // becomes double; maybe surprising

Prefer a named type or named value

Make the conversion deliberate.

double v2 = flag ? 0.0 : 1.5;

Applied task

Choose one pitfall and describe the smallest change that makes the code easier to review.

Guarded value selection

The division arm is chosen only when the denominator is non-zero.

double safe_divide(double numerator, double denominator) {
    return denominator != 0.0 ? numerator / denominator : 0.0;
}

Applied task

Explain which expression is skipped when denominator is zero, and why that matters.

Max of two

The expression returns one of the two input values.

int max2(int a, int b) {
    return (a > b ? a : b);
}

Choose formatter lazily

Only the chosen formatting function runs.

std::string format_short();
std::string format_long();
bool brief = /* ... */;

std::string msg = (brief ? format_short() : format_long());

Lvalue assignment through ?:

This mutates left when toLeft is true, otherwise right.

int left = 0, right = 0;
bool toLeft = true;

(toLeft ? left : right) += 10;

Applied task

For each worked example, decide whether ?: is the clearest teaching form or whether an if version would be clearer.

Prefer simple arms

This version is compact without hiding a complicated branch.

const char* label = score >= 50 ? "pass" : "fail";

Use statements when the work is real

Logging, mutation and multi-step behaviour are clearer as statements.

if (score >= 50) {
    record_pass(student);
    notify(student);
} else {
    record_fail(student);
    schedule_support(student);
}

Applied task

Decide which example should remain an if/else and justify the choice in terms of side effects and readability.

Applied task

Use the checklist to decide whether one branch from your own code should become ?: or stay as an if.

Case 1: Assignment-only branch

A code review finds five if/else blocks that only assign one of two literal values. Decide which ones become clearer as ?: and which need named predicates first.

Case 2: Stream insertion surprise

A learner writes std::cout << x > y ? x : y; and gets unexpected behaviour or a compile error. Explain how parentheses make the intended conditional value explicit.

Case 3: Hidden side effects

A developer uses condition ? save() : rollback() inside a larger expression. Decide whether this hides too much control flow and propose a clearer rewrite.

A. Convert a simple assignment

The branch only assigns one of two values.

int result;
if (score >= 50) {
    result = 1;
} else {
    result = 0;
}

• Convert the branch to a conditional expression.
• Explain what value the expression produces when score is 49.
• Decide whether a named predicate would improve readability.

const bool passed = score >= 50;
int result = passed ? 1 : 0;

B. Parenthesise inside a stream expression

Make the selected value explicit before it is inserted into the stream.

std::cout << x > y ? x : y;

• Add parentheses so the stream receives the selected value.
• Explain why the unparenthesised form is risky.
• Trace the output when x = 3 and y = 7.

std::cout << (x > y ? x : y);

C. Use ?: as a function argument

Select one argument before calling the function.

auto choose = [](int a, int b) { return a + b; };
int x = 3, y = 7;
int z = choose((x > y ? x : y), 10);

• State the first argument passed to choose.
• State the final value of z.
• Rewrite with a named larger variable if that would be clearer for a novice.

const int larger = x > y ? x : y;
int z = choose(larger, 10);

D. Use ?: as an initializer

Choose a small tag value at the point of declaration.

int x = 3;
const char* tag = (x % 2 == 0 ? "even" : "odd");

• State the value of tag when x is 3.
• Explain why this is a good use of ?:.
• Rewrite using std::string_view if you prefer a modern library type.

std::string_view tag = (x % 2 == 0 ? "even" : "odd");

E. Reject an unsuitable ternary

This branch performs actions, not just value selection.

if (ok) {
    write_file();
    log_success();
} else {
    report_error();
}

• Explain why this should remain statement-level control flow.
• Identify the side effects in each branch.
• Suggest a helper function only if it improves naming and testability.

Keep the `if`/`else`. The branches perform actions and communicate control flow more clearly as statements.

F. Check arm types

Legal conversions can still surprise readers.

auto v = (flag ? 0 : 1.5);

• State the resulting type of v.
• Rewrite so the intended type is explicit.
• Explain why matching arm types helps code review.

const double v = flag ? 0.0 : 1.5;

G. Assign through an lvalue conditional

Both arms are lvalues of the same type, so the selected object can be assigned.

int a = 1, b = 2;
bool cond = false;
(cond ? a : b) = 42;

• State which variable changes when cond is false.
• Explain why the whole expression is an lvalue.
• Decide whether this is clearer than an if for a novice audience.

if (cond) {
    a = 42;
} else {
    b = 42;
}

H. Replace a nested ternary

Right-associative nesting is compact but often poor teaching code.

auto label = a ? "A" : c ? "C" : "other";

• Show how the expression parses.
• Rewrite using ordinary if statements.
• Explain which version is easier to debug.

const char* label = "other";
if (a) {
    label = "A";
} else if (c) {
    label = "C";
}

I. Convert and embed

Convert the branch to ?:, then use it as an initializer.

int score = /* ... */;
std::string label;
if (score >= 50) {
    label = "pass";
} else {
    label = "fail";
}

• Convert the assignment to a conditional initializer.
• State the type of label.
• Explain why this conversion preserves behaviour.

std::string label = (score >= 50 ? "pass" : "fail");

J. Use ?: as a function argument

Choose the logging level at the call site.

void log_level(const char*);
bool verbose = /* ... */;

log_level(verbose ? "debug" : "info");

• State which argument is passed when verbose is true.
• Explain why both arms have compatible types.
• Add parentheses if that improves readability in your house style.

log_level((verbose ? "debug" : "info"));