C++ ternary operator (?:): syntax and examples

The C++ ternary operator, condition ? a : b, is an expression that gives a when the condition is true and b when it is false. It is a compact if-else that produces a value, so it can sit where a statement cannot: in an initializer, a return or a function argument. Its formal name is the conditional operator.

A test score, in a whole program:

#include <iostream>
#include <string>

int main() {
    int score = 72;
    std::string result = score >= 60 ? "pass" : "fail";
    std::cout << "Score " << score << ": " << result << '\n';
}

It printed:

Score 72: pass

Read the line as “if the score is at least 60, then pass, otherwise fail”. score >= 60 is the condition, anything that converts to bool; 72 meets it, so result holds “pass”. The operator needs no header and has been in C++ since C++98. The samples are C++17 (Since When’s C++17 table lists the first GCC, Clang and MSVC releases for its features), built with MSVC 19.44, Clang 19.1 (MSVC STL), GCC 16.2 and Clang 23.1 (libc++), and all four printed the same.

Ternary operator vs if-else: what is the difference?

An if-else is a statement, a step the program carries out: it does one thing or another. The ternary operator is an expression, a piece of code that has a value: it is one value or another. The same choice, both ways:

std::string by_if;
if (score >= 60) {
    by_if = "pass";
} else {
    by_if = "fail";
}

std::string by_ternary = score >= 60 ? "pass" : "fail";

std::cout << by_if << ' ' << by_ternary << '\n';  // pass pass

int age = 9;
const int fee = age < 12 ? 5 : 10;  // a const set in one step
std::cout << "Fee: " << fee << '\n';  // Fee: 5

The if-else declares by_if empty and sets it in one of two places; the ternary sets by_ternary as it is declared. That matters for the entry fee: fee is const, a variable that cannot change once set, so an if-else could not assign it afterwards, while the ternary gives it its value in one step.

When should you use the ternary operator?

Use it for a short choice between two values: to initialize a variable, in a return, as a function argument, or to pick a singular or plural word. Each of those is a place that needs a value:

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

void announce(const char* result) {
    std::cout << "Result: " << result << '\n';
}

int main() {
    std::cout << larger(72, 85) << '\n';  // 85

    int score = 72;
    announce(score >= 60 ? "pass" : "fail");  // Result: pass

    int count = 1;
    std::cout << count << (count == 1 ? " item" : " items") << '\n';
    count = 3;
    std::cout << count << (count == 1 ? " item" : " items") << '\n';
}

The last two lines printed 1 item and 3 items. Write an if-else instead when the two sides do different things rather than give different values, or when either side is long enough that the ? and the : get lost in it.

What type does the ternary operator return (numbers and strings)?

The whole expression has one type, worked out from both branches: an int and a double give a double, and a string literal (text in double quotes) with a std::string gives a std::string (the conditional operator on cppreference). Below, decltype names the type of an expression and std::is_same_v asks whether two types are the same:

std::cout << std::boolalpha;

bool member = true;
auto price = member ? 8 : 9.5;  // int and double: double
std::cout << std::is_same_v<decltype(price), double> << '\n';
std::cout << price << '\n';  // 8, held as 8.0

bool ok = true;
std::string label = ok ? "yes" : std::string("no");
std::cout << label << '\n';  // yes

// the type of each whole expression, checked by the compiler
using Mixed = decltype(ok ? "yes" : std::string("no"));
using Words = decltype(ok ? "yes" : "no");
std::cout << std::is_same_v<Mixed, std::string> << '\n';
std::cout << std::is_same_v<Words, const char*> << '\n';

Every check printed true. price is a double though member picked the 8, and std::cout printed it as 8. Two string literals, ok ? "yes" : "no", give a pointer to characters (const char*), not a std::string. With auto, the first example’s result would have been a const char*. To get a std::string from a choice between two pieces of text, declare the variable as std::string, as that example does, or make one branch a std::string, as label does.

Branches with no common type do not compile:

auto value = ok ? 1 : "none";  // error: a number or text?

GCC said:

error: operands to '?:' have different types 'int' and 'const char*'

All four refused it. One branch may instead be a throw, which has no value; the expression then takes the other branch’s type (how try, catch and throw work).

Can you nest ternary operators?

Yes. A nested ternary operator has another ternary as a branch, and laid out with one condition per line it reads as a chain. A letter grade from a score, beside the same chain as an if-else:

char grade_ternary(int score) {
    return score >= 90 ? 'A'
         : score >= 80 ? 'B'
         : score >= 70 ? 'C'
         : score >= 60 ? 'D'
         : 'F';
}

char grade_if(int score) {
    if (score >= 90) {
        return 'A';
    } else if (score >= 80) {
        return 'B';
    } else if (score >= 70) {
        return 'C';
    } else if (score >= 60) {
        return 'D';
    } else {
        return 'F';
    }
}

For 95, 72 and 41 both returned A, C and F. The operator groups from the right, so the chain is read as score >= 90 ? 'A' : (score >= 80 ? 'B' : ...) with no parentheses written: each line that starts with : is the else of the line above it. Past three outcomes, prefer the if-else chain: it is as easy to scan, and any branch can grow into more than a value.

Why does cout << x ? a : b print the wrong thing?

Because << binds tighter than ?:, std::cout << passed ? "pass" : "fail"; sends passed to the stream and throws the chosen word away. Put the ternary in parentheses:

bool passed = true;

std::cout << passed ? "pass" : "fail";  // prints 1
std::cout << '\n';

std::cout << (passed ? "pass" : "fail") << '\n';  // prints pass

It printed:

1
pass

The first line is read as (std::cout << passed) ? "pass" : "fail"; (the operator precedence table puts << far above ?:), so the bool is printed as 1, the stream itself (which converts to bool) becomes the condition, and the chosen word goes nowhere. Do not count on a warning: Clang says operator '?:' has lower precedence than '<<'; '<<' will be evaluated first even with no warning flags, GCC with -Wall only that the second and third operands, the two values, have no effect, and MSVC at /W4 says nothing.

With a comparison as the condition, the same slip does not compile:

std::cout << score >= 60 ? "pass" : "fail";  // error

<< runs first again, so >= is asked to compare the stream with 60. GCC said no match for 'operator>=', and all four refused it. The same parentheses fix it, and they are why the item lines earlier wrap their choice in them. An assignment needs none: a = b ? c : d is read as a = (b ? c : d).

Does the ternary operator evaluate both sides?

No. Only the chosen branch runs ([expr.cond]: “only one of the second and third expressions is evaluated”), which is what makes count != 0 ? total / count : 0 safe:

int pass_bonus() {
    std::cout << "pass_bonus called\n";
    return 5;
}

int fail_bonus() {
    std::cout << "fail_bonus called\n";
    return 0;
}
// ...
int score = 72;
int bonus = score >= 60 ? pass_bonus() : fail_bonus();
std::cout << "bonus " << bonus << '\n';

int total = 0;
int count = 0;
int average = count != 0 ? total / count : 0;  // no division
std::cout << "average " << average << '\n';

It printed pass_bonus called, bonus 5 and average 0: fail_bonus never ran, and with count at 0 the division was never evaluated.

Ternary or if-else: which one?

Pick by what the code has to produce:

C++ does not let you overload ?:; how to overload operators in C++ covers the ones you can. The Language section has the other answers on the core language.