book

Rust for C++ Developers

Name: Rust for C++ Developers
Author: Dan Olson
ISBN: 9781836206514

by Dan Olson

March 2026

Intermediate

318 pages

7h 52m

English

Packt Publishing

Read now

Unlock full access

Preface
Free benefits with your book
Part 1: Understanding Rust Basics
Chapter 1: Why Choose Rust?
A brief history of RustEarly beginnings at MozillaStabilizing the languageExpanding into new territoryHow Rust can improve softwareHigh level, low levelSafety by defaultPerformance and memoryModern language and toolingCrates and the Rust ecosystemThe anatomy of a crateAdding dependencies on community cratesSummaryGet this book's PDF version and more
Chapter 2: Working with Rust Syntax
Technical requirementsDeclaring variables and structuresUsing simple variablesLearning array syntaxWorking with structuresUsing functions and methodsFunctions and block expressionsUsing methods to add behavior to structuresCalling functions and methodsMoving around the programUsing conditionalsUsing loops and breaksUnderstanding generic programmingUsing generic structuresSpecifying generic behavior with traitsLearning pattern matchingUsing supercharged enumerations in RustMatching patternsSummaryGet this book's PDF version and more
Chapter 3: The Rust Safety Model
Technical requirementsTracking ownershipThe single ownership principleCleaning up old dataWhen shallow copies are enoughBorrowing dataBorrowing immutable dataBorrowing mutable dataDereferencing borrowsBorrowing with method callsSpecifying lifetimesUnderstanding lifetime annotationsLifetimes in functionsLifetimes in structuresUnderstanding panicsPanicking as a safety mechanismAvoiding panicsChanging how we write codeAvoiding references in structuresUsing copyable structures oftenLearning not to fear cloningUsing indices instead of referencesSummaryGet this book's PDF version and more
Chapter 4: Managing Rust Projects with Cargo
Technical requirementsStructuring a Rust projectCreating a basic projectFile structure of a crateUnderstanding modulesWorking with binariesWorking with dependenciesExploring Rust's community cratesManaging dependencies with CargoConfiguring dependenciesAdding non-Rust dependenciesPublishing cratesSetting up an accountPreparing a crate for publishingUnderstanding semantic versioningSending a crate to the repositoryExploring Cargo's capabilitiesUsing Cargo as a test runnerInstalling software with CargoVendoring dependenciesExtending Cargo with pluginsSummary
Part 2: Exploring the Rust Standard Library
Chapter 5: Data Structures
Technical requirementsFundamentals of Rust data structuresProperties of strings in RustOwned and borrowed typesConverting between owned and borrowed typesCustomizing dereference behavior in RustWorking with indexed dataUsing array typesFlexible runtime sizing with vectorsWorking with borrowed data using slicesUsing dictionary typesFlavors of map and set in RustBasic map and set usageUsing the entry APIEnabling custom key typesSummaryGet this book's PDF version and more
Chapter 6: Reading and Writing Files
Technical requirementsWorking with filesUsing filesystem pathsHandling errors in RustUnderstanding high-level IO abstractionsExploring the Rust I/O APIOpening files for reading or writingUnderstanding fundamental I/O traitsExtending the I/O APIsSimple serialization and deserializationReading a JSON file using serdeCustomizing serialization behaviorWriting out JSONSummaryGet this book's PDF version and more
Chapter 7: Understanding Iterators
Technical requirementsDefining and creating iteratorsWhat is an iterator?The properties of Rust iteratorsCreating iteratorsConsuming and composing iteratorsLooping through iteratorsFunctions on the iterator traitComposing iterators with adaptersExamining iterator performanceDissecting an iterator expressionVectorization optimizationsSummaryGet this book's PDF version and more

Chapter 8: Object-Oriented Programming
Technical requirementsUnderstanding object-oriented principlesAbstracting behavior and encapsulating dataModeling problems with inheritance and polymorphismExamining object-oriented foundations in RustImplementation and data visibilityComposition over inheritanceDynamic dispatch in RustLimitations of dynamic dispatchMoving beyond object orientationModeling problems with Rust enumsCombining functional and object-oriented stylesSummaryGet this book's PDF version and more
Chapter 9: Working with C++ in Rust
Technical requirementsCommunicating between Rust and CUnderstanding the C ABIDeclaring C-compatible structures in RustCalling C functions from RustExposing Rust functions to CGenerating and updating bindingsUsing bindgen to keep bindings up to dateCompiling and linking C librariesStrategies for C++ bindingManually creating bindingsCalling C++ directly from a Rust programUsing bindings effectivelySummaryGet this book's PDF version and more
Part 3: Moving into Advanced Rust
Chapter 10: Optimization in Rust
Technical requirementsUnderstanding the performance of safe RustAliasingInitialization and bounds checkingMoving and cloningMeasuring the performance of Rust programsProducing a test caseAnnotating blocks of codeSampling profilersBenchmarkingImproving performance using unsafe Rust codeRemoving bounds checksAvoiding expensive initializationOptimizing with SIMD instructionsSetting up nightly RustWriting a SIMD functionSummary
Chapter 11: Multithreading in Rust
Technical requirementsCreating and managing threadsSpawning new threadsScoped threadsThread poolingMultithreading safely in RustUnderstanding race conditionsData races and the borrow checkerSynchronizing data across threadsMutual exclusionAtomic reference countingUseful multithreading techniquesParallel iterators with RayonUsing channelsAtomics and lock-free programmingSummary
Chapter 12: Metaprogramming with Macros
Technical requirementsPitfalls of the preprocessorSyntactic fragilityVariable captureDeclarative macrosCreating declarative macros in RustCreating our first macroExpanding our capabilities with repetitionMatching explicit tokensPractical considerations for declarative macrosChoosing delimitersImplications of mixed-site hygieneProcedural macrosCommon properties of procedural macrosCustom deriveAttribute-like macrosFunction-like macrosMacro best practicesError handlingDebugging and testingSummary
Chapter 13: Continuing with Rust
Practicing Rust at homeOnline challengesHobby projectsNavigating Rust in the workplaceIntroducing Rust to professionalsSearching for a Rust careerKeeping up with RustUnderstanding the Rust communityStaying up to date with RustSummary
Appendix: Setting Up The Development Environment
Installing Rust development toolsObtaining Rust development toolsVerifying installationManaging a Rust installation with rustupSetting up Visual Studio Code for Rust developmentInstalling Visual Studio CodeUsing the Rust analysis extensionDebugging Rust in Visual Studio CodeUsing Clippy, the Rust linterWorking with ClippyConfiguring Clippy for your projectGet this book's PDF version and more
Chapter 15: Unlock Your Exclusive Benefits
Unlock this Book's Free Benefits in 3 Easy StepsStep 1Step 2Step 3Need Help
Index

Content preview from Rust for C++ Developers

Part 1 Understanding Rust Basics

In this first part of the book, we'll explore the basics of Rust, including the technical benefits of the language and its tooling. You'll see Rust syntax in the context of equivalent code in C++, when possible. By the end of this part, you'll be able to read most Rust code and understand where and why Rust chooses different trade-offs from C++. You'll be able to create a basic project in Rust, and you'll have a good understanding of the tooling that supports the Rust ecosystem.

This part of the book includes the following chapters:

Chapter 1, Why Choose Rust?
Chapter 2, Working with Rust Syntax
Chapter 3, The Rust Safety Model
Chapter 4, Managing Rust Projects with Cargo

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

Read now

Unlock full access

More than 5,000 organizations count on O’Reilly

O’Reilly covers everything we've got, with content to help us build a world-class technology community, upgrade the capabilities and competencies of our teams, and improve overall team performance as well as their engagement.

Julian F.

Head of Cybersecurity

I wanted to learn C and C++, but it didn't click for me until I picked up an O'Reilly book. When I went on the O’Reilly platform, I was astonished to find all the books there, plus live events and sandboxes so you could play around with the technology.

Addison B.

Field Engineer

I’ve been on the O’Reilly platform for more than eight years. I use a couple of learning platforms, but I'm on O'Reilly more than anybody else. When you're there, you start learning. I'm never disappointed.

Amir M.

Data Platform Tech Lead

I'm always learning. So when I got on to O'Reilly, I was like a kid in a candy store. There are playlists. There are answers. There's on-demand training. It's worth its weight in gold, in terms of what it allows me to do.

Mark W.

Embedded Software Engineer

Publisher Resources

ISBN: 9781836206514

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills

Rust for C++ Developers

by Dan Olson

Part 1

Understanding Rust Basics

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.