What Does `??!??!` Mean in C? Trigraphs and How the Code Really Works

By the end of this page, you will understand that ??!??! is not a real C operator. It works because C historically supports trigraphs, where certain three-character sequences are replaced before compilation. In this case, ??! becomes |, so ??!??! becomes ||, the logical OR operator. You will also learn why the example behaves like a normal condition check, why trigraphs are confusing, and why modern C code should avoid them.

In C, ??!??! is not a special operator with its own meaning. Instead, it is the result of a very old language feature called trigraphs.

A trigraph is a sequence of three characters that the compiler replaces with a different single character very early in translation. This feature existed to support keyboards and character sets that could not easily type some punctuation characters used by C.

Here are a few trigraphs:

Think of trigraphs as a secret keyboard translation step that happens before the compiler really reads your code.

Imagine you write a note using substitute symbols because your keyboard is missing some keys:

• every time you write ??!, a helper rewrites it to |

So:

??!??!

becomes:

||

Then the compiler reads the code normally.

For the || part, think of it like this:

• "Try the first thing."
• "If that is enough to decide the result, stop."
• "Otherwise, try the second thing."

So:

A || B

means:

• if A is true, no need to check B
• if A is false, then check B

That is why functions on the right side of || may or may not run.

The core idea here is really about trigraph replacement and logical OR.

Trigraph example

??!   /* becomes | */

So this:

a ??!??! b

becomes:

a || b

Normal logical OR syntax

if (x == 0 || y == 0) {
    printf("At least one value is zero\n");
}

This means:

• if x == 0 is true, the whole condition is true
• otherwise, C checks y == 0

Equivalent version of the strange code

ErrorHasOccured() || HandleError();

A clearer beginner-friendly example

#include <stdio.h>

int has_error {
     ;
}

  {
    ();
     ;
}

  {
    has_error() || handle_error();
     ;
}

Consider this code:

#include <stdio.h>

int first(void) {
    printf("first() called\n");
    return 0;
}

int second(void) {
    printf("second() called\n");
    return 1;
}

int main(void) {
    first() ??!??! second();
    return 0;
}

Step 1: Trigraph replacement

Before normal compilation, C replaces trigraphs:

first() ??!??! second();

becomes:

first() || second();

Step 2: Evaluate the left side

first() runs first.

Output:

first() called

It returns , which means false.

Although trigraphs themselves are rarely used today, the logical OR with short-circuit evaluation is very common.

1. Fallback logic

config_loaded() || load_default_config();

If the main configuration fails, load a default one.

2. Error reporting

is_valid(input) || log_error("Invalid input");

If validation fails, log an error.

3. Guard-style checks

ptr != NULL || abort();

If ptr is null, terminate immediately.

4. Parsing and validation

read_header(file) || handle_bad_file();

If the header cannot be read successfully, handle the failure.

5. Command-line tools and scripts written in C

Short-circuit expressions are sometimes used to keep code compact when a fallback action should run only if the first check fails.

That said, many teams prefer a normal if statement because it is easier to read.

In real C codebases, developers usually rely on the logical OR operator directly, not trigraphs.

Common patterns

Guard clauses

if (ptr == NULL) {
    return -1;
}

This is clearer than writing compressed expressions.

Early returns

if (!init_system()) {
    return 0;
}

This avoids deep nesting.

Validation before work

if (!is_valid_user(user)) {
    log_error("Invalid user");
    return;
}

Short-circuit for compact code

socket_ready() || reconnect_socket();

This may appear in low-level utility code, but should be used carefully.

Why trigraphs are avoided

• they are hard to recognize
• many programmers have never seen them
• they can make debugging and searching harder
• modern keyboards no longer need this workaround

In modern codebases, if you see ??!??!, it is usually either:

Mistake 1: Thinking ??!??! is a unique operator

It is not. It becomes || through trigraph replacement.

Broken assumption:

a ??!??! b   /* not a special custom operator */

Correct understanding:

a || b

Mistake 2: Misreading the logic direction

A lot of people assume this means "if error, then handle error," but that depends on the return value.

ErrorHasOccured() || HandleError();

If ErrorHasOccured() returns 1 for error, then HandleError() will not run.

Always verify what the function returns.

Mistake 3: Forgetting that C uses integers as truth values

In C:

• 0 means false
• non-zero means true

Broken mental model:

if (5 == true) {
    
}

|| vs |

Key fact

??!??! in C is not its own operator.

It is two trigraphs:

??!  ->  |
??!  ->  |

So:

??!??!  ->  ||

What || does

a || b

• evaluates a first
• if a is true, b is not evaluated
• if a is false, b is evaluated

Truth rules in C

• 0 = false
• non-zero = true

Example

ErrorHasOccured() || HandleError();

Equivalent meaning:

if (!ErrorHasOccured()) {
    HandleError();
}

returns non-zero when successful and on failure. Always check the function's contract.

Is ??!??! a real C operator?

No. It becomes || because of trigraph replacement.

Why did C have trigraphs at all?

They were added so C could be written on systems or keyboards that lacked some punctuation characters.

Does ErrorHasOccured() ??!??! HandleError(); always mean "if error, handle error"?

No. It only means ErrorHasOccured() || HandleError();. Whether HandleError() runs depends on the return value of ErrorHasOccured().

What is short-circuit evaluation in C?

It means || stops early if the left side is already true, and && stops early if the left side is already false.

Are trigraphs still used in modern C?

Very rarely. They are considered obsolete and are usually avoided.

What should I write instead of this?

Use || directly, or better, use an explicit if statement when readability matters.

Is | the same as || in C?

No. is bitwise OR, while is logical OR with short-circuit behavior.

• Logical OR operator (||) — This is the actual operator produced after trigraph replacement.
• Short-circuit evaluation — Explains why the right-hand function may not run.
• Truthy and falsy values in C — Important because C uses 0 and non-zero integers as boolean values.
• Bitwise OR (|) — Related because trigraph ??! produces the | character.
• if statements in C — A clearer alternative to compact boolean expressions.
• Logical AND operator (&&) — Similar control-flow behavior with short-circuiting.
• Preprocessing and translation phases — Trigraph replacement happens before normal parsing.
• Digraphs in C — Another alternate-token feature, less obscure than trigraphs.