Modern C++ for Systems Code: What to Use and What to Avoid

C++ has changed substantially since C++11, and code written in the modern style looks and behaves very differently from the C with classes many systems codebases still contain. Smart pointers, views, compile-time evaluation and stronger types remove whole classes of bugs at little or no runtime cost. Other features bring heap allocation, code size or unpredictable timing that matter on constrained or real-time targets. This article sets out a practical subset for systems work.

At a glance

RAII
Resources are released by destructors, so cleanup happens on every path, including errors.
C++17
A widely supported baseline across desktop, mobile and embedded toolchains.
constexpr
Computation moved to compile time costs nothing when the program runs.
Zero cost
Many modern abstractions compile to the same machine code as the hand-written version.

The problem

Older systems code manages memory and resources by hand: raw new and delete, pointer and length pairs passed separately, and cleanup code duplicated on every return path. Each is a place where a leak, a double free or an overrun can hide.

The opposite mistake is adopting every feature at once. Exceptions, run-time type information, iostreams and casual use of containers that allocate can add code size and unpredictable timing that a small or real-time target cannot afford.

Use modern C++ to make the type system do the checking. Avoid the features whose costs you cannot see or bound.

What to prefer

Prefer std::unique_ptr over owning raw pointers, std::array over C arrays, std::span and std::string_view over separate pointer and length arguments, enum class over plain enums, and constexpr values over macros. Each makes intent explicit and lets the compiler catch misuse.

On constrained targets, decide early whether exceptions and RTTI are enabled, since many embedded projects and safety standards disable them. Avoid heap allocation after start-up in real-time paths, or use fixed-capacity containers and allocators that draw from preallocated pools.

What good looks like

Pick a language standard that every target toolchain supports fully, and enable strict warnings, treated as errors, from the first commit.

Write a short project guideline listing the features to prefer and those that are restricted, with the reason for each, and enforce what you can with clang-tidy.

Modernise legacy code gradually, starting where bugs cluster: resource ownership, buffer handling and error paths.

Modern replacements for older patterns
FeatureStandardReplaces
std::unique_ptrC++11Owning raw pointers with manual delete
enum classC++11Plain enums that convert to integers silently
std::optionalC++17Sentinel values and success flags
std::string_viewC++17Character pointers passed with lengths
std::spanC++20Pointer and size argument pairs
std::expectedC++23Error codes returned beside output parameters
The standard in which each feature first appeared.
Exceptions and error values in constrained code
ExceptionsError values
Runtime supportUnwinding tables and library codeNone beyond the type
TimingHard to boundPredictable
PropagationAutomatic through layersExplicit at each call
Silent failureUnhandled ones terminatePossible unless marked nodiscard
Both are valid C++. Embedded and real-time projects usually choose error values.

What it changes

Fewer Defects

Ownership and bounds expressed in types remove leaks and overruns at compile time.

Readability

Code states its intent, which makes reviews faster and handovers easier.

Predictable Cost

A restricted subset keeps code size, memory and timing within known limits.

Maintainability

A consistent style across the codebase is easier to extend than a mix of eras.

Where to go next

The C++ Core Guidelines are a well-reasoned reference. Adopt the parts that suit your targets rather than the whole document at once.

Measure before deciding a feature is too expensive. Compiler output and map files show the real cost, which is often different from what was assumed.

Problems this prevents

  • Leaks and double frees from manual ownership
  • Overruns from separate pointer and length
  • Hidden heap allocation in real-time paths
  • A codebase written in several incompatible styles

Discuss your project

Email support@aavico.com or use Get in Touch when the website finishes loading.