DEV Community: Tomáš Svojanovský

Boolean Expressions, If Statements, and the Ternary Operator in C++

Tomáš Svojanovský — Sun, 31 May 2026 06:00:00 +0000

Boolean logic is one of the most basic but important parts of programming. In C++, boolean expressions are used whenever we need to make decisions in our code.

If you already know another programming language, most of this will feel familiar. C++ uses the same basic ideas: true, false, comparison operators, if statements, else if, else, and the ternary operator.

Let’s go through them step by step.

Boolean Values in C++

C++ has a built-in boolean type called bool.

A bool variable can only store one of two values:

bool b1 = true;
bool b2 = false;

Both true and false are keywords in C++, and they are written in lowercase.

This is important. For example, this is correct:

bool isReady = true;

But this is not valid C++:

bool isReady = True; // wrong

Boolean Expressions

A boolean expression is an expression that evaluates to either true or false.

For example:

bool b1 = true;
bool b2 = false;

bool c1 = b1 == b2;

Here, b1 == b2 checks whether b1 and b2 have the same value.

Since b1 is true and b2 is false, the result is false.

So c1 stores:

false

C++ supports the usual comparison operators:

==  // equal to
!=  // not equal to
<   // less than
>   // greater than
<=  // less than or equal to
>=  // greater than or equal to

You can also combine boolean expressions using logical operators:

&&  // and
||  // or
!   // not

Example:

bool b1 = true;
bool b2 = false;

bool result = b1 || b2;

This means:

true OR false

So the result is true.

Use Parentheses for Clarity

In many programming languages, including C++, operator precedence determines which parts of an expression are evaluated first.

For simple expressions, this is usually obvious. But once you combine multiple conditions, the code can become harder to read.

For example:

bool result = b1 || b2 && !b1;

This works, but it is not immediately clear what the programmer intended.

A clearer version would be:

bool result = b1 || (b2 && !b1);

Or maybe this was intended:

bool result = (b1 || b2) && !b1;

These two expressions are different.

That is why it is usually a good idea to add parentheses when combining conditions. The goal is not just to make the compiler understand the code, but also to make the code understandable for humans.

If Statements

The most common place where boolean expressions are used is inside if statements.

Example:

#include <iostream>

int main()
{
    bool b1 = true;

    if (b1 == true)
    {
        std::cout << "Printing\n";
    }

    return 0;
}

The condition inside the parentheses is evaluated.

If the condition is true, the code inside the curly braces runs.

If the condition is false, the code block is skipped.

In this example, b1 == true is true, so the program prints:

Printing

Shorter Boolean Checks

When a variable is already a boolean, you do not need to compare it explicitly to true.

Instead of writing this:


if (b1 == true)
{
    std::cout << "Printing\n";
}

You can write:

if (b1)
{
    std::cout << "Printing\n";
}

This is shorter and more idiomatic.

Both versions mean the same thing:

if b1 is true, run this block

Similarly, instead of writing:

if (b1 == false)
{
    std::cout << "Not printing\n";
}

You can write:

if (!b1)
{
    std::cout << "Not printing\n";
}

The ! operator means “not”.

So:

!b1

means:

not b1

If b1 is true, then !b1 is false.

If b1 is false, then !b1 is true.

Else If and Else

C++ also supports else if and else.

Example:

#include <iostream>

int main()
{
    bool b1 = false;
    bool b2 = false;

    if (b1)
    {
        std::cout << "b1 is true\n";
    }
    else if (!b2)
    {
        std::cout << "b2 is false\n";
    }
    else
    {
        std::cout << "No condition matched\n";
    }

    return 0;
}

Here is what happens:

First, C++ checks if (b1).
If that is false, it checks else if (!b2).
If that is also false, it runs the else block.

In this example, b1 is false and b2 is also false.

So:

!b2

is true.

The output will be:

b2 is false

Curly Braces in If Statements

In C++, curly braces define the body of an if, else if, or else block.

This is the recommended style:


if (b1)
{
    std::cout << "b1 is true\n";
}

Technically, if the body contains only one statement, you can omit the curly braces:

if (b1)
    std::cout << "b1 is true\n";

This is valid C++.

However, it can easily become dangerous when you add more lines later.

For example:

if (b1)
    std::cout << "b1 is true\n";
    std::cout << "This always runs\n";

Only the first line belongs to the if statement.

The second line always runs, because it is not inside a block.

That is why many developers prefer to always use curly braces, even for one-line if statements:


if (b1)
{
    std::cout << "b1 is true\n";
    std::cout << "This only runs if b1 is true\n";
}

This style is safer and easier to maintain.

Compiler Warnings and Unused Variables

When writing code like this:

bool b1 = true;
bool b2 = false;

bool c1 = b1 == b2;

you may see a compiler warning if c1 is never used.

The warning may say something like:

unused variable 'c1'

or:

local variable is initialized but not referenced

This means that you created a variable, stored a value in it, but never used it later.

For example:

bool c1 = b1 == b2;

If c1 is not used anywhere else, then the variable is unnecessary.

Compiler warnings are useful because they help you detect code that may be redundant, wasteful, or incorrect.

In modern C++ development, it is common to enable many compiler warnings. They help you catch problems early.

The Ternary Operator

Sometimes you want to assign one value if a condition is true, and another value if the condition is false.

You can do this with a normal if statement:


#include <cstdint>

int main()
{
    bool b1 = true;

    std::int32_t result;

    if (b1)
    {
        result = 10;
    }
    else
    {
        result = -10;
    }

    return 0;
}

This works perfectly fine.

But C++ also gives us a shorter way to write this: the ternary operator.

std::int32_t result = b1 ? 10 : -10;

The structure is:

condition ? value_if_true : value_if_false

So this:

std::int32_t result = b1 ? 10 : -10;

means:

if b1 is true, store 10
otherwise, store -10

If b1 is true, then result becomes 10.

If b1 is false, then result becomes -10.

Ternary Operator vs If Statement

The ternary operator is useful when you want to choose between two values.

For example:

std::int32_t result = b1 ? 10 : -10;

This is much shorter than:

std::int32_t result;

if (b1)
{
    result = 10;
}
else
{
    result = -10;
}

However, the ternary operator should not be overused.

This is readable:

std::int32_t result = b1 ? 10 : -10;

But this is much harder to understand:

std::int32_t result = b1 ? 10 : b2 ? 20 : b3 ? 30 : -10;

Nested ternary expressions can quickly become difficult to read.

In that case, an if, else if, else structure is usually better:


std::int32_t result;

if (b1)
{
    result = 10;
}
else if (b2)
{
    result = 20;
}
else if (b3)
{
    result = 30;
}
else
{
    result = -10;
}

This is longer, but it is much clearer.

When Should You Use the Ternary Operator?

Use the ternary operator when:

you are choosing between two simple values
the condition is easy to read
the whole expression stays short

Good example:

std::int32_t result = isPositive ? 1 : -1;

Avoid the ternary operator when:

you need multiple branches
the expression becomes too long
you are doing more than just selecting a value
readability suffers

Bad example:

std::int32_t result = a > b ? x + y * z : c < d ? p - q : r / s;

This may compile, but it is not pleasant to read.

Summary

Boolean expressions are used to control the flow of a program.

In C++, a bool can store either true or false. You can use comparison operators and logical operators to build conditions, and those conditions can be used inside if, else if, and else statements.

The ternary operator is a shorter alternative to a simple if-else assignment. It is useful when you want to choose between two values, but it should be used carefully. If the expression becomes too complex, a normal if statement is usually better.

In general:


if (condition)
{
    // use this for control flow
}

And:

auto value = condition ? value_if_true : value_if_false;

Use the ternary operator mainly for simple value selection.

Readable code is more important than short code.

Integers and Floating-Point Numbers in C++

Tomáš Svojanovský — Sat, 30 May 2026 07:22:48 +0000

File Extensions in C++

Before we start writing code, it is worth mentioning that C++ source files can use different file extensions.

Common C++ file extensions include:

.cc
.cpp
.cxx

All three are valid for C++ source files.

In practice, .cpp and .cc are probably the most common ones. The .cxx extension is also valid, but you will usually see it less often.

For this example, let’s imagine we create a file called:

integers_floats.cpp

Integer Types in C++

An integer is a whole number without a fractional part.

Examples of integers are:

In C++, integers can be either:

signed
unsigned

A signed integer can store both negative and positive values.

An unsigned integer can store only zero and positive values.

For example:

-10   // signed
0     // signed or unsigned
42    // signed or unsigned

Fixed-Width Integer Types

C++ provides a standard library header called:

#include <cstdint>

This header gives us access to fixed-width integer types.

These are useful because they allow us to specify exactly how many bits an integer should use.

For example:

std::int32_t

This means:

a signed integer with 32 bits

Here is a simple example:

#include <cstdint>

int main() {
    std::int32_t i1 = 0;
}

The type std::int32_t stores a signed 32-bit integer.

Signed and Unsigned Integer Types

The header gives us several useful integer types.

Signed integer types:

std::int8_t
std::int16_t
std::int32_t
std::int64_t

Unsigned integer types:

std::uint8_t
std::uint16_t
std::uint32_t
std::uint64_t

The number in the type name tells us how many bits the type uses.

For example:

std::int8_t   // signed 8-bit integer
std::int16_t  // signed 16-bit integer
std::int32_t  // signed 32-bit integer
std::int64_t  // signed 64-bit integer

And for unsigned integers:

std::uint8_t   // unsigned 8-bit integer
std::uint16_t  // unsigned 16-bit integer
std::uint32_t  // unsigned 32-bit integer
std::uint64_t  // unsigned 64-bit integer

A larger number of bits means the type can store a larger range of values.

For example, a 64-bit integer can store much larger values than an 8-bit integer.

Example: Using Fixed-Width Integer Types

Here is an example using several integer types:

#include <cstdint>

int main() {
    std::int8_t i8 = 0;
    std::int16_t i16 = 0;
    std::int32_t i32 = 0;
    std::int64_t i64 = 0;

    std::uint8_t u8 = 0;
    std::uint16_t u16 = 0;
    std::uint32_t u32 = 0;
    std::uint64_t u64 = 0;
}

This gives us a clear way to define the size and signedness of our integer variables.

Integer Literals and the U Suffix

When writing unsigned integer values, you can add a U suffix to the number.

For example:

std::uint32_t value = 42U;

The U tells the compiler that the literal should be treated as unsigned.

You can use either lowercase or uppercase:

42u
42U

Both are valid.

Personally, I prefer the uppercase version because it is easier to see.

For larger unsigned values, you may also see suffixes like:

42ULL

This means an unsigned long long literal, which is usually used for larger integer values.

For now, the important thing to remember is this:

U

is commonly used to indicate that a number is unsigned.

Floating-Point Types in C++

Integers are useful for whole numbers.

But what if we need decimal values?

For example:

3.14
12.5
0.001

For these values, C++ provides floating-point types.

The two most common floating-point types are:

float
double

A float is usually a 32-bit floating-point number.

A double is usually a 64-bit floating-point number.

Example:

int main() {
    float f1 = 12.0F;
    double d1 = 12.0;
}

Why Use F with Float Literals?

In C++, a decimal literal such as this:

12.0

is interpreted as a double by default.

So if you write:

float f1 = 12.0;

the value on the right side is first treated as a double, and then it is stored into a float.

To make it clear that the literal itself should be a float, you can add the F suffix:

float f1 = 12.0F;

You can also write:

float f1 = 12.0f;

Both lowercase f and uppercase F are valid.

Again, I prefer uppercase because it is easier to read.

float and double Compared to Other Languages

Some modern languages use names such as:

float32
float64

For example, Rust has:

f32
f64

C++ does not use these names directly for built-in floating-point types.

Instead, C++ uses:

float   // usually 32-bit
double  // usually 64-bit

You can define your own aliases if you want names like float32 or float64, but that is a topic for another article.

Boolean Values

C++ also has a boolean type:

bool

A boolean can store one of two values:

true
false

Example:

int main() {
    bool is_active = true;
    bool is_finished = false;
}

A boolean is not usually considered a numeric type in the same way as integers and floats, but it is still one of the fundamental primitive types in C++.

Characters in C++

C++ also has a character type:

char

A char stores a single character.

Example:

int main() {
    char c1 = 'A';
    char c2 = 'z';
}

Notice the single quotation marks:

'A'
'z'

Single quotation marks are used for single characters.

Double quotation marks are used for strings:

'A'    // character
"A"    // string

This distinction is very important in C++.

Characters Are Integers Under the Hood

Although we use char for characters, under the hood characters are represented as integer values.

For example, the character:

'A'

is mapped to a numeric value using a character encoding table such as ASCII.

In ASCII, characters like A, B, C, a, b, and c all correspond to numeric values.

That means char is closely related to integer types internally.

However, when storing single characters, we normally use:

char

instead of:

std::int8_t
std::uint8_t

Even though they may be similar in size, char better communicates the intention: we are storing a character, not just a small number.

Why Not Just Use int?

In many C++ tutorials, you will often see code like this:

int value = 42;

This works, and int is still very commonly used.

However, the exact size of int can depend on the platform and compiler.

For example, on one system an int might be 32 bits. On another system, such as some embedded platforms, it might be 16 bits.

That means when you write:

int value = 42;

you do not always know exactly how many bits the type has.

For modern C++ code, especially when the exact size matters, fixed-width integer types from are often a better choice.

For example:

std::int32_t value = 42;

This makes the intention much clearer.

You are saying:

I want a signed integer with exactly 32 bits.

Summary

C++ gives us several ways to store numeric values.

For integers, we can use fixed-width types from the header:

std::int8_t
std::int16_t
std::int32_t
std::int64_t
std::uint8_t
std::uint16_t
std::uint32_t
std::uint64_t

For decimal values, we usually use:

float
double

For boolean values, we use:

bool

And for single characters, we use:

char

The key idea is that different types have different sizes, ranges, and meanings.

Latency: What It Really Means, How It’s Measured, and Why Every Field Sees It Differently

Tomáš Svojanovský — Thu, 04 Dec 2025 16:27:04 +0000

Latency is basically the delay between the moment you start a task and the moment it finishes. Every system has some latency — if it’s doing any work at all, it can never be truly zero. In some systems, the latency is so small that it’s just a fraction of a millisecond, and there even an extra microsecond of delay can be a big problem.

Applications that must respond extremely quickly are called low-latency applications. For these, the goal is to respond and return results as fast as possible. If latency rises, the system can slow down, degrade in performance, or even completely break.

But if it runs with the expected low latency, it can:

beat the competition
run at maximum performance
handle more work (higher throughput)
increase productivity
or improve the user experience

Depending on what the application does.

Latency is both a quantitative and a qualitative concept.

Quantitatively, it’s just time
Qualitatively, it depends on the context — some systems can tolerate latency measured in seconds (like loading a webpage), but once a video starts playing, it can’t afford multi-second pauses

That would kill the entire experience.

And then there’s the extreme case: high-frequency trading (HFT). There, a few microseconds decide whether a company is profitable or irrelevant.

It’s a world where people optimize the network, software, CPU, RAM, and even the physical cables — all to shave off microseconds.

How Is Latency Actually Measured?

You can measure latency in multiple ways. The difference is mainly where you start measuring and where you stop. Here are the most common metrics.

1) Time To First Byte (TTFB)

The time between:

T₁: when the sender transmits the first byte
T₂: when the receiver reads that first byte

Useful for networks, APIs, or streaming. It shows how quickly the server starts responding, not how fast it completes the whole response.

2) Round-Trip Time (RTT)

The full “there and back” cycle:

Send → deliver → process → respond → deliver

RTT includes the time the other side spends processing the data. It’s the complete picture of real-world response time.

In trading, RTT consists of three parts:

time for market data to reach the participant
time for the system to make a decision
time for the order to reach the exchange

3) Tick-to-Trade (TTT)

A special trading-specific metric.

It measures only what happens inside your infrastructure:

How long from receiving a packet until you send an order back

TTT = pure algorithm + infrastructure reaction time.

In practice → when you receive market data, how fast can you send a trade?

This is where microseconds matter.

4) CPU Clock Cycles

The lowest-level measurement — CPU cycles.

Useful for analyzing:

how fast a specific instruction executes
pipeline behavior, branch mispredictions, cache hits/misses
how different compilers generate assembly

This is “high-end optimization” where you tune the last few percent of performance.

Latency vs Throughput: Don’t Mix Them Up

People often confuse latency and throughput, but they’re entirely different.

Latency = how fast you finish one thing
Throughput = how many things you finish per unit of time

If you want high throughput, you use parallelism — individual tasks might take longer but you complete more of them.

If you want low latency, every single operation must be fast.

Key Latency Metrics

Mean latency

Average of all measurements.

Median latency

Better representation of reality. Unaffected by extreme outliers.

Peak latency

Worst-case scenario. Crucial in real-time systems.

Latency variance (jitter)

How much latency fluctuates.

Become a member

Extremely important in HFT, robotics, and automotive — you need predictability.

What Do Latency-Sensitive Applications Need?

Robustness and correctness
Low-latency systems process huge amounts of data. They must be stable.

Low mean and median latency

Both need to stay minimal.

Capped peak latency

You must guarantee the upper bound — the system must never “fall apart” and spike to seconds.

Low variance

Even if average latency is low, occasional millisecond-level spikes are bad.

High throughput

Sometimes handling a massive load is more important than the absolute fastest single operation.

Example — Server vs Client

T₁ — server sends the first byte

Server starts transmitting the packet.

T₂ — client receives the first byte

Client gets the first data from the server.

→ T₂ − T₁ = TTFB (server → client)

T₃ — client sends a response

Client processes the data and sends a packet back.

T₄ — server receives the first byte of the response

→ T₄ − T₃ = TTFB (client → server)

Full RTT

If you want the entire round-trip time:

RTT = (T₂ − T₁) + (T₄ − T₃)

In many cases, you add the client processing time (T₂ → T₃), so:

Real-world RTT = T₄ − T₁

The full cycle from sending to receiving.

Why Should You Care?

Latency is not just a technical parameter.

It’s a competitive advantage, a quality-of-experience factor, and in some fields (trading, automotive, robotics), it’s literally a matter of life and death.

And here’s the fascinating part:

Every field sees latency completely differently.

How React Thinks About Latency

In the React world, latency is not about microseconds.

React doesn’t care if a function takes 80 ns or 120 ns.

React focuses on:

keeping the UI “responsive enough” for humans
avoiding flicker, tearing, and unnecessary re-renders
preventing users from feeling slowdowns
scheduling work so the UI stays interactive

React concepts around latency:

Concurrent rendering — pause work to keep the UI smooth
Transitions — mark lower-priority updates
React Compiler — eliminate unnecessary re-renders

Here, latency is measured in tens or hundreds of milliseconds, because humans don’t notice anything under ~16 ms.

400 ms? Fine.
1 second? Annoying.
2 seconds? Now it’s a problem.

In this world, latency is a psychological experience more than a technical one.

And Then There’s the Opposite Extreme: Trading, Robotics, Automotive

These fields don’t care about “user experience.”

A single microsecond can mean:

your algorithm loses to competitors
a robot doesn’t react in time
a car fails to compute a braking trajectory

React couldn’t care less if something takes 0.1 ms instead of 1 ms.

Trading systems absolutely care.

They’d lose money — and relevance — over a 0.001 ms difference.

And There’s a “Third World” — Typical Backends and APIs

Here, latency is measured in:

milliseconds (e.g., 20–200 ms)
the focus is throughput, scaling, caching, parallelization
as long as requests finish within a few hundred ms, everything is fine

This is the kind of system where “latency” means something completely different than in HFT or real-time control.

The Point

Understanding latency is all about understanding context:

In React, you optimize for UI smoothness and user perception
In backend systems, you optimize for scaling and throughput
In robotics and trading, you optimize for microsecond reaction times

And yet all these fields use the exact same word: latency.

Just in completely different universes.

Why C++ Still Matters: A Modern Look for Today’s Developers

Tomáš Svojanovský — Fri, 28 Nov 2025 20:21:24 +0000

C++ has been around for decades, but it’s still one of the most important languages in the world.

Whether you’re building games, trading systems, robotics applications, or high-performance backends, C++ continues to dominate the domains where speed, control, and reliability matter most.

1. C++ Is Everywhere — More Than You Think

C++ quietly powers a massive part of the software ecosystem.

Game engines like Unreal are almost entirely written in C++ to render millions of polygons each second.

Web browsers (Chrome) rely on C++ for JavaScript engines, layout engines, and rendering pipelines — the most performance-critical pieces.

Graphics, physics, and audio pipelines across all platforms are built from C++ for maximum efficiency.

Embedded devices, sometimes with only kilobytes of memory, depend on C++ to get fine-grained control with minimal overhead.

If it needs to run fast or run everywhere, chances are it’s using C++.

2. Flexibility and Portability: C++ Runs on Anything

One reason C++ survived decades of new languages is its range.
The same language can target:

massive cloud servers processing thousands of operations per second
standard desktop computers
tiny microcontrollers managing sensors
flight computers in aircraft and spacecraft

Very few languages can deliver both high-level abstractions and near-metal performance across this wide spectrum.

3. From Pointers to Smart Pointers: Modern C++ Gives You a Choice

C++ inherits raw low-level control from C: manual memory, pointers, direct hardware access.

But modern C++ gives you safe, high-level tools too:

Smart pointers (unique_ptr, shared_ptr)
RAII for automatic resource management
Standard containers (vector, map, unordered_map)
Robust type safety and templates

You can write C++ like a low-level system engineer or like a high-level application developer — the choice is yours.

4. The Power of Open Standardization

C++ isn’t owned by a corporation.
Its evolution is guided by ISO’s WG21 committee, made up of compiler authors, industry experts, and academics.

The last decade transformed the language:

C++11 introduced lambdas, auto, move semantics
C++14/17 refined the modern style
C++20 brought concepts, coroutines, and ranges
C++23 continued improving usability and compile-time power

Modern C++ feels nothing like the 90s version. It’s faster, safer, more expressive, and significantly more pleasant to write.

5. Quality-of-Life Features That Changed Everything

New language features massively improved developer experience:

auto reduces noise and improves readability
Lambdas make callbacks, algorithms, and small functions easy
Ranges bring fluent, Python-like data transformations with compile-time guarantees
Smart pointers eliminate many memory bugs

Modern C++ lets you write expressive, high-level code without giving up control.

6. Why Certain Industries Still Choose C++

C++ remains dominant in fields where performance is non-negotiable.

AAA game engines rely on it for stable 60–120 FPS loops.

High-frequency trading (HFT) uses C++ because microseconds literally mean money.

Robotics needs deterministic performance and tight hardware control.

Scientific computing depends on C++ for large simulations (climate models, epidemiology, physics).

If every microsecond counts, C++ wins.

7. Yes — C++ Has Dangerous Parts. But Modern C++ Helps You Avoid Them

With great power comes… undefined behavior.

Classic C++ bugs include:

segmentation faults
buffer overflows
memory leaks,
dereferencing invalid pointers

On a regular PC this means a crash.
On embedded hardware, it can mean bricking the device.

But modern C++ provides safe defaults:

smart pointers
RAII patterns
containers instead of raw arrays
standard algorithms instead of manual loops

You only drop to low-level code when you really need to.

8. A Rich, Optimized Standard Library

The C++ standard library is huge and extremely optimized:

Data structures: vectors, lists, hash tables, trees, heaps, queues…
Algorithms: sort, search, transform, accumulate, shuffle, partition…
Compile-time features: constexpr, templates, concepts

You rarely need to reinvent anything — the STL implementations are battle-tested and highly tuned by compiler vendors.

9. Multi-Paradigm: Program However You Want

C++ is one of the most flexible languages ever created.

You can write:

Object-oriented: classes, inheritance, polymorphism
Functional: lambdas, ranges, immutability
Generic: templates, concepts

Low-level systems code: memory management, hardware access.

Instead of forcing a paradigm, C++ gives you tools that match your problem
domain.

10. Better Syntax for Humans and Compilers

Modern syntax makes generic programming far more accessible:

Trailing return types (auto func() -> type) help readability with complex templates.

decltype lets you extract types from expressions.

Return type deduction removes boilerplate from functions and templates.

These features help C++ scale into extremely large and complex codebases — which is why industries like finance and gaming rely on it for long-lived projects.

C++ Isn’t Going Anywhere

C++ is fast, flexible, portable, and more modern than ever.
It powers the most performance-critical systems on Earth, yet it now offers the high-level tools needed to write safer and cleaner code.

If you’re a developer who wants to understand how software really works — from hardware to abstractions — C++ remains one of the strongest languages you can learn.