100% found this document useful (5 votes)
14 views66 pages

Instant Download Modern C++ For Absolute Beginners: A Friendly Introduction To The C++ Programming Language and C++11 To C++23 Standards, 2nd Edition Slobodan Dmitrović PDF All Chapters

Introduction

Uploaded by

mgracetoolu
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
100% found this document useful (5 votes)
14 views66 pages

Instant Download Modern C++ For Absolute Beginners: A Friendly Introduction To The C++ Programming Language and C++11 To C++23 Standards, 2nd Edition Slobodan Dmitrović PDF All Chapters

Introduction

Uploaded by

mgracetoolu
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 66

Download Full Version ebookmass - Visit ebookmass.

com

Modern C++ for Absolute Beginners: A Friendly


Introduction to the C++ Programming Language and
C++11 to C++23 Standards, 2nd Edition Slobodan
Dmitrović
https://ebookmass.com/product/modern-c-for-absolute-
beginners-a-friendly-introduction-to-the-c-programming-
language-and-c11-to-c23-standards-2nd-edition-slobodan-
dmitrovic/

OR CLICK HERE

DOWLOAD NOW

Discover More Ebook - Explore Now at ebookmass.com


Instant digital products (PDF, ePub, MOBI) ready for you
Download now and discover formats that fit your needs...

Modern C for Absolute Beginners: A Friendly Introduction


to the C Programming Language 2nd Edition Slobodan
Dmitrovi■
https://ebookmass.com/product/modern-c-for-absolute-beginners-a-
friendly-introduction-to-the-c-programming-language-2nd-edition-
slobodan-dmitrovic/
ebookmass.com

Modern C++ for Absolute Beginners 2nd Edition Slobodan


Dmitrovi■

https://ebookmass.com/product/modern-c-for-absolute-beginners-2nd-
edition-slobodan-dmitrovic/

ebookmass.com

Modern C for Absolute Beginners - Second Edition Solbodan


Dmitrovic

https://ebookmass.com/product/modern-c-for-absolute-beginners-second-
edition-solbodan-dmitrovic/

ebookmass.com

Workbook for Radiologic Science for Technologists E Book:


Physics, Biology, and Protection 11th Edition, (Ebook PDF)

https://ebookmass.com/product/workbook-for-radiologic-science-for-
technologists-e-book-physics-biology-and-protection-11th-edition-
ebook-pdf/
ebookmass.com
The Tokyo University Trial and the Struggle Against Order
in Postwar Japan Christopher Perkins

https://ebookmass.com/product/the-tokyo-university-trial-and-the-
struggle-against-order-in-postwar-japan-christopher-perkins/

ebookmass.com

Basic Electronics QuickStart Guide : Understanding the


Basic John Thomas

https://ebookmass.com/product/basic-electronics-quickstart-guide-
understanding-the-basic-john-thomas/

ebookmass.com

Bad Apple Lancaster Hill

https://ebookmass.com/product/bad-apple-lancaster-hill/

ebookmass.com

Captured and Bound: Rugged Mountain Goliaths (Mountain


Goliaths: Rugged Mountain Ink Book 4) Khloe Summers

https://ebookmass.com/product/captured-and-bound-rugged-mountain-
goliaths-mountain-goliaths-rugged-mountain-ink-book-4-khloe-summers/

ebookmass.com

Autoimmune Diseases in Domestic Animals Ian R. Tizard

https://ebookmass.com/product/autoimmune-diseases-in-domestic-animals-
ian-r-tizard/

ebookmass.com
Casarett & Doull's Essentials of Toxicology 4th Edition
Ph.D. Klaassen

https://ebookmass.com/product/casarett-doulls-essentials-of-
toxicology-4th-edition-ph-d-klaassen/

ebookmass.com
Modern C++ for Absolute
Beginners
A Friendly Introduction to the C++
Programming Language and C++11
to C++23 Standards
Second Edition

Slobodan Dmitrović
Modern C++ for Absolute Beginners: A Friendly Introduction to the C++
Programming Language and C++11 to C++23 Standards

Slobodan Dmitrović
Belgrade, Serbia

ISBN-13 (pbk): 978-1-4842-9273-0 ISBN-13 (electronic): 978-1-4842-9274-7


https://doi.org/10.1007/978-1-4842-9274-7

Copyright © 2023 by Slobodan Dmitrović


This work is subject to copyright. All rights are reserved by the Publisher, whether the whole or part of the
material is concerned, specifically the rights of translation, reprinting, reuse of illustrations, recitation,
broadcasting, reproduction on microfilms or in any other physical way, and transmission or information
storage and retrieval, electronic adaptation, computer software, or by similar or dissimilar methodology now
known or hereafter developed.
Trademarked names, logos, and images may appear in this book. Rather than use a trademark symbol with
every occurrence of a trademarked name, logo, or image we use the names, logos, and images only in an
editorial fashion and to the benefit of the trademark owner, with no intention of infringement of the
trademark.
The use in this publication of trade names, trademarks, service marks, and similar terms, even if they are not
identified as such, is not to be taken as an expression of opinion as to whether or not they are subject to
proprietary rights.
While the advice and information in this book are believed to be true and accurate at the date of publication,
neither the authors nor the editors nor the publisher can accept any legal responsibility for any errors or
omissions that may be made. The publisher makes no warranty, express or implied, with respect to the
material contained herein.
Managing Director, Apress Media LLC: Welmoed Spahr
Acquisitions Editor: Steve Anglin
Development Editor: James Markham
Coordinating Editor: Gryffin Winkler
Cover image designed by eStudioCalamar
Distributed to the book trade worldwide by Springer Science+Business Media New York, 1 New York Plaza,
Suite 4600, New York, NY 10004-1562, USA. Phone 1-800-SPRINGER, fax (201) 348-4505, e-mail orders-ny@
springer-sbm.com, or visit www.springeronline.com. Apress Media, LLC is a California LLC and the sole
member (owner) is Springer Science + Business Media Finance Inc (SSBM Finance Inc). SSBM Finance Inc
is a Delaware corporation.
For information on translations, please e-mail booktranslations@springernature.com; for reprint,
paperback, or audio rights, please e-mail bookpermissions@springernature.com.
Apress titles may be purchased in bulk for academic, corporate, or promotional use. eBook versions and
licenses are also available for most titles. For more information, reference our Print and eBook Bulk Sales
web page at http://www.apress.com/bulk-sales.
Any source code or other supplementary material referenced by the author in this book is available to
readers on GitHub via the book’s product page, located at www.apress.com/. For more detailed information,
please visit http://www.apress.com/source-code.
Printed on acid-free paper
To Mary Anne,
whose work is an inspiration to me.
Table of Contents
About the Author�����������������������������������������������������������������������������������������������������xv

About the Technical Reviewer�������������������������������������������������������������������������������xvii


Acknowledgments��������������������������������������������������������������������������������������������������xix

About the Second Edition���������������������������������������������������������������������������������������xxi

Chapter 1: Introduction�������������������������������������������������������������������������������������������� 1

Chapter 2: What Is C++?������������������������������������������������������������������������������������������ 3


C++ Standards����������������������������������������������������������������������������������������������������������������������������� 3

Chapter 3: C++ Compilers���������������������������������������������������������������������������������������� 5


Installing C++ Compilers�������������������������������������������������������������������������������������������������������������� 5
On Linux����������������������������������������������������������������������������������������������������������������������������������� 5
On Windows����������������������������������������������������������������������������������������������������������������������������� 6

Chapter 4: Our First Program����������������������������������������������������������������������������������� 7


Comments������������������������������������������������������������������������������������������������������������������������������������� 7
Hello World Example��������������������������������������������������������������������������������������������������������������������� 8

Chapter 5: Types����������������������������������������������������������������������������������������������������� 13
Fundamental Types��������������������������������������������������������������������������������������������������������������������� 13
Boolean���������������������������������������������������������������������������������������������������������������������������������� 13
Character Type����������������������������������������������������������������������������������������������������������������������� 14
Integer Types������������������������������������������������������������������������������������������������������������������������� 16
Floating-Point Types�������������������������������������������������������������������������������������������������������������� 18
Type void������������������������������������������������������������������������������������������������������������������������������� 18
Type Modifiers����������������������������������������������������������������������������������������������������������������������������� 19
Variable Declaration, Definition, and Initialization����������������������������������������������������������������������� 19

v
Table of Contents

Chapter 6: Exercises����������������������������������������������������������������������������������������������� 21
Hello World and Comments��������������������������������������������������������������������������������������������������������� 21
Declaration���������������������������������������������������������������������������������������������������������������������������������� 21
Definition������������������������������������������������������������������������������������������������������������������������������������� 22
Initialization��������������������������������������������������������������������������������������������������������������������������������� 22

Chapter 7: Operators���������������������������������������������������������������������������������������������� 25
Assignment Operator������������������������������������������������������������������������������������������������������������������ 25
Arithmetic Operators������������������������������������������������������������������������������������������������������������������� 25
Compound Assignment Operators���������������������������������������������������������������������������������������������� 27
Increment/Decrement Operators������������������������������������������������������������������������������������������������ 28

Chapter 8: Standard Input�������������������������������������������������������������������������������������� 29

Chapter 9: Exercises����������������������������������������������������������������������������������������������� 31
Standard Input���������������������������������������������������������������������������������������������������������������������������� 31
Two Inputs����������������������������������������������������������������������������������������������������������������������������������� 31
Multiple Inputs���������������������������������������������������������������������������������������������������������������������������� 32
Inputs and Arithmetic Operations����������������������������������������������������������������������������������������������� 33
Postincrement and Compound Assignment�������������������������������������������������������������������������������� 33
Integral and Floating-Point Division�������������������������������������������������������������������������������������������� 34

Chapter 10: Arrays�������������������������������������������������������������������������������������������������� 35


Chapter 11: Pointers����������������������������������������������������������������������������������������������� 37

Chapter 12: References������������������������������������������������������������������������������������������ 41

Chapter 13: Introduction to Strings������������������������������������������������������������������������ 43


Defining a String������������������������������������������������������������������������������������������������������������������������� 43
Concatenating Strings����������������������������������������������������������������������������������������������������������������� 44
Accessing Characters����������������������������������������������������������������������������������������������������������������� 45
Comparing Strings���������������������������������������������������������������������������������������������������������������������� 46
String Input��������������������������������������������������������������������������������������������������������������������������������� 47
A Pointer to a String�������������������������������������������������������������������������������������������������������������������� 48

vi
Table of Contents

Substrings����������������������������������������������������������������������������������������������������������������������������������� 48
Finding a Substring��������������������������������������������������������������������������������������������������������������������� 49

Chapter 14: Automatic Type Deduction������������������������������������������������������������������ 51

Chapter 15: Exercises��������������������������������������������������������������������������������������������� 53


Array Definition��������������������������������������������������������������������������������������������������������������������������� 53
Pointer to an Object�������������������������������������������������������������������������������������������������������������������� 54
Reference Type��������������������������������������������������������������������������������������������������������������������������� 54
Strings����������������������������������������������������������������������������������������������������������������������������������������� 55
Strings from Standard Input�������������������������������������������������������������������������������������������������������� 55
Creating a Substring������������������������������������������������������������������������������������������������������������������� 56
Finding a Single Character���������������������������������������������������������������������������������������������������������� 57
Finding a Substring��������������������������������������������������������������������������������������������������������������������� 58
Automatic Type Deduction���������������������������������������������������������������������������������������������������������� 59

Chapter 16: Statements������������������������������������������������������������������������������������������ 61


Selection Statements������������������������������������������������������������������������������������������������������������������ 61
if Statement��������������������������������������������������������������������������������������������������������������������������� 61
Conditional Expression���������������������������������������������������������������������������������������������������������� 63
The Logical Operators����������������������������������������������������������������������������������������������������������� 65
switch Statement������������������������������������������������������������������������������������������������������������������ 70
Iteration Statements������������������������������������������������������������������������������������������������������������������� 71
for Statement������������������������������������������������������������������������������������������������������������������������ 72
while Statement�������������������������������������������������������������������������������������������������������������������� 73
do Statement������������������������������������������������������������������������������������������������������������������������� 75

Chapter 17: Constants�������������������������������������������������������������������������������������������� 77

Chapter 18: Exercises��������������������������������������������������������������������������������������������� 79


A Simple if Statement����������������������������������������������������������������������������������������������������������������� 79
Logical Operators������������������������������������������������������������������������������������������������������������������������ 80
The switch Statement����������������������������������������������������������������������������������������������������������������� 81

vii
Table of Contents

The for Loop�������������������������������������������������������������������������������������������������������������������������������� 82


Array and the for Loop���������������������������������������������������������������������������������������������������������������� 83
The const Type Qualifier�������������������������������������������������������������������������������������������������������������� 83

Chapter 19: Functions�������������������������������������������������������������������������������������������� 85


Introduction��������������������������������������������������������������������������������������������������������������������������������� 85
Function Declaration������������������������������������������������������������������������������������������������������������������� 85
Function Definition���������������������������������������������������������������������������������������������������������������������� 86
Return Statement������������������������������������������������������������������������������������������������������������������������ 89
Passing Arguments��������������������������������������������������������������������������������������������������������������������� 91
Passing by Value/Copy����������������������������������������������������������������������������������������������������������� 91
Passing by Reference������������������������������������������������������������������������������������������������������������ 92
Passing by Const Reference�������������������������������������������������������������������������������������������������� 93
Function Overloading������������������������������������������������������������������������������������������������������������������ 94

Chapter 20: Exercises��������������������������������������������������������������������������������������������� 97


Function Definition���������������������������������������������������������������������������������������������������������������������� 97
Separate Declaration and Definition������������������������������������������������������������������������������������������� 97
Function Parameters������������������������������������������������������������������������������������������������������������������� 98
Passing Arguments��������������������������������������������������������������������������������������������������������������������� 99
Function Overloads��������������������������������������������������������������������������������������������������������������������� 99

Chapter 21: Scope and Lifetime���������������������������������������������������������������������������� 101


Local Scope������������������������������������������������������������������������������������������������������������������������������� 101
Block Scope������������������������������������������������������������������������������������������������������������������������������ 101
Lifetime������������������������������������������������������������������������������������������������������������������������������������� 102
Automatic Storage Duration������������������������������������������������������������������������������������������������������ 102
Dynamic Storage Duration�������������������������������������������������������������������������������������������������������� 102
Static Storage Duration������������������������������������������������������������������������������������������������������������� 103
Operators new and delete��������������������������������������������������������������������������������������������������������� 103

viii
Table of Contents

Chapter 22: Exercises������������������������������������������������������������������������������������������� 105


Automatic Storage Duration������������������������������������������������������������������������������������������������������ 105
Dynamic Storage Duration�������������������������������������������������������������������������������������������������������� 106
Automatic and Dynamic Storage Durations������������������������������������������������������������������������������ 107

Chapter 23: Classes – Introduction���������������������������������������������������������������������� 109


Data Member Fields������������������������������������������������������������������������������������������������������������������ 109
Member Functions�������������������������������������������������������������������������������������������������������������������� 110
Access Specifiers���������������������������������������������������������������������������������������������������������������������� 112
Constructors������������������������������������������������������������������������������������������������������������������������������ 116
Default Constructor������������������������������������������������������������������������������������������������������������� 116
Member Initialization����������������������������������������������������������������������������������������������������������� 119
Copy Constructor����������������������������������������������������������������������������������������������������������������� 120
Copy Assignment����������������������������������������������������������������������������������������������������������������� 123
Move Constructor���������������������������������������������������������������������������������������������������������������� 124
Move Assignment���������������������������������������������������������������������������������������������������������������� 126
Operator Overloading���������������������������������������������������������������������������������������������������������������� 128
Destructors������������������������������������������������������������������������������������������������������������������������������� 134

Chapter 24: Exercises������������������������������������������������������������������������������������������� 137


Class Instance��������������������������������������������������������������������������������������������������������������������������� 137
Class with Data Members��������������������������������������������������������������������������������������������������������� 137
Class with Member Function���������������������������������������������������������������������������������������������������� 138
Class with Data and Function Members����������������������������������������������������������������������������������� 139
Class Access Specifiers������������������������������������������������������������������������������������������������������������ 139
User-Defined Default Constructor and Destructor�������������������������������������������������������������������� 140
Constructor Initializer List��������������������������������������������������������������������������������������������������������� 141
User-Defined Copy Constructor������������������������������������������������������������������������������������������������� 143
User-Defined Move Constructor������������������������������������������������������������������������������������������������ 144
Overloading Arithmetic Operators��������������������������������������������������������������������������������������������� 145

ix
Table of Contents

Chapter 25: Classes – Inheritance and Polymorphism����������������������������������������� 147


Inheritance�������������������������������������������������������������������������������������������������������������������������������� 147
Polymorphism��������������������������������������������������������������������������������������������������������������������������� 151

Chapter 26: Exercises������������������������������������������������������������������������������������������� 157


Inheritance�������������������������������������������������������������������������������������������������������������������������������� 157

Chapter 27: The static Specifier��������������������������������������������������������������������������� 161

Chapter 28: Templates������������������������������������������������������������������������������������������ 165


Function Templates������������������������������������������������������������������������������������������������������������������� 165
Class Templates������������������������������������������������������������������������������������������������������������������������ 167
Template Specialization������������������������������������������������������������������������������������������������������������ 171

Chapter 29: Enumerations������������������������������������������������������������������������������������ 173

Chapter 30: Exercises������������������������������������������������������������������������������������������� 177


Static Variable��������������������������������������������������������������������������������������������������������������������������� 177
Static Data Member������������������������������������������������������������������������������������������������������������������ 178
Static Member Function������������������������������������������������������������������������������������������������������������ 179
Function Template��������������������������������������������������������������������������������������������������������������������� 180
Class Template�������������������������������������������������������������������������������������������������������������������������� 181
Scoped Enums�������������������������������������������������������������������������������������������������������������������������� 182
Enums in a switch��������������������������������������������������������������������������������������������������������������������� 183

Chapter 31: Organizing Code�������������������������������������������������������������������������������� 185


Header and Source Files����������������������������������������������������������������������������������������������������������� 185
Header Guards�������������������������������������������������������������������������������������������������������������������������� 186
Namespaces����������������������������������������������������������������������������������������������������������������������������� 186

Chapter 32: Exercises������������������������������������������������������������������������������������������� 191


Header and Source Files����������������������������������������������������������������������������������������������������������� 191
Multiple Source Files���������������������������������������������������������������������������������������������������������������� 192
Namespaces����������������������������������������������������������������������������������������������������������������������������� 193
Nested Namespaces����������������������������������������������������������������������������������������������������������������� 194

x
Table of Contents

Chapter 33: Conversions�������������������������������������������������������������������������������������� 197


Implicit Conversions������������������������������������������������������������������������������������������������������������������ 197
Explicit Conversions������������������������������������������������������������������������������������������������������������������ 201

Chapter 34: Exceptions����������������������������������������������������������������������������������������� 205

Chapter 35: Smart Pointers���������������������������������������������������������������������������������� 211


Unique Pointer�������������������������������������������������������������������������������������������������������������������������� 211
Shared Pointer�������������������������������������������������������������������������������������������������������������������������� 214

Chapter 36: Exercises������������������������������������������������������������������������������������������� 217


static_cast Conversion�������������������������������������������������������������������������������������������������������������� 217
A Simple Unique Pointer����������������������������������������������������������������������������������������������������������� 218
Unique Pointer to an Object of a Class�������������������������������������������������������������������������������������� 218
Shared Pointer Exercise������������������������������������������������������������������������������������������������������������ 219
Simple Polymorphism��������������������������������������������������������������������������������������������������������������� 220
Polymorphism II������������������������������������������������������������������������������������������������������������������������ 221
Exception Handling������������������������������������������������������������������������������������������������������������������� 222
Multiple Exceptions������������������������������������������������������������������������������������������������������������������� 223

Chapter 37: Input/Output Streams������������������������������������������������������������������������ 225


File Streams������������������������������������������������������������������������������������������������������������������������������ 225
String Streams�������������������������������������������������������������������������������������������������������������������������� 229

Chapter 38: C++ Standard Library and Friends���������������������������������������������������� 235


Containers��������������������������������������������������������������������������������������������������������������������������������� 235
std::vector���������������������������������������������������������������������������������������������������������������������������� 236
std::array����������������������������������������������������������������������������������������������������������������������������� 238
std::set��������������������������������������������������������������������������������������������������������������������������������� 239
std::map������������������������������������������������������������������������������������������������������������������������������ 241
std::pair������������������������������������������������������������������������������������������������������������������������������� 244
Other Containers������������������������������������������������������������������������������������������������������������������ 245
The Range-Based for Loop������������������������������������������������������������������������������������������������������� 245
Iterators������������������������������������������������������������������������������������������������������������������������������������ 248

xi
Table of Contents

Algorithms and Utilities������������������������������������������������������������������������������������������������������������� 251


std::sort������������������������������������������������������������������������������������������������������������������������������� 252
std::find������������������������������������������������������������������������������������������������������������������������������� 254
std::copy������������������������������������������������������������������������������������������������������������������������������ 255
Min and Max Elements�������������������������������������������������������������������������������������������������������� 257
Lambda Expressions����������������������������������������������������������������������������������������������������������������� 258

Chapter 39: Exercises������������������������������������������������������������������������������������������� 267


Basic Vector������������������������������������������������������������������������������������������������������������������������������ 267
Deleting a Single Value������������������������������������������������������������������������������������������������������������� 268
Deleting a Range of Elements��������������������������������������������������������������������������������������������������� 268
Finding Elements in a Vector���������������������������������������������������������������������������������������������������� 269
Basic Set����������������������������������������������������������������������������������������������������������������������������������� 270
Set Data Manipulation��������������������������������������������������������������������������������������������������������������� 271
Set Member Functions�������������������������������������������������������������������������������������������������������������� 272
Search for Data in a Set������������������������������������������������������������������������������������������������������������ 273
Basic Map��������������������������������������������������������������������������������������������������������������������������������� 274
Inserting into a Map������������������������������������������������������������������������������������������������������������������ 275
Searching and Deleting from a Map����������������������������������������������������������������������������������������� 277
Lambda Expressions����������������������������������������������������������������������������������������������������������������� 278

Chapter 40: C++ Standards���������������������������������������������������������������������������������� 281


C++11��������������������������������������������������������������������������������������������������������������������������������������� 281
Automatic Type Deduction��������������������������������������������������������������������������������������������������� 282
Range-Based Loops������������������������������������������������������������������������������������������������������������ 282
Initializer Lists��������������������������������������������������������������������������������������������������������������������� 283
Move Semantics������������������������������������������������������������������������������������������������������������������ 284
Lambda Expressions����������������������������������������������������������������������������������������������������������� 284
The constexpr Specifier������������������������������������������������������������������������������������������������������� 285
Scoped Enumerators����������������������������������������������������������������������������������������������������������� 286
Smart Pointers��������������������������������������������������������������������������������������������������������������������� 286

xii
Table of Contents

std::unordered_set�������������������������������������������������������������������������������������������������������������� 288
std::unordered_map������������������������������������������������������������������������������������������������������������ 290
std::tuple����������������������������������������������������������������������������������������������������������������������������� 292
static_assert������������������������������������������������������������������������������������������������������������������������ 293
Introduction to Concurrency������������������������������������������������������������������������������������������������ 294
Deleted and Defaulted Functions���������������������������������������������������������������������������������������� 301
Type Aliases������������������������������������������������������������������������������������������������������������������������� 304
C++14��������������������������������������������������������������������������������������������������������������������������������������� 304
Binary Literals��������������������������������������������������������������������������������������������������������������������� 305
Digit Separators������������������������������������������������������������������������������������������������������������������� 306
Auto for Functions��������������������������������������������������������������������������������������������������������������� 306
Generic Lambdas����������������������������������������������������������������������������������������������������������������� 307
std::make_unique���������������������������������������������������������������������������������������������������������������� 307
C++17��������������������������������������������������������������������������������������������������������������������������������������� 308
Nested Namespaces������������������������������������������������������������������������������������������������������������ 308
Constexpr Lambdas������������������������������������������������������������������������������������������������������������� 309
Structured Bindings������������������������������������������������������������������������������������������������������������� 309
std::filesystem��������������������������������������������������������������������������������������������������������������������� 311
std::string_view������������������������������������������������������������������������������������������������������������������� 315
std::any�������������������������������������������������������������������������������������������������������������������������������� 317
std::variant�������������������������������������������������������������������������������������������������������������������������� 319
C++20��������������������������������������������������������������������������������������������������������������������������������������� 322
Modules������������������������������������������������������������������������������������������������������������������������������� 323
Concepts������������������������������������������������������������������������������������������������������������������������������ 325
Lambda Templates�������������������������������������������������������������������������������������������������������������� 329
[likely] and [unlikely] Attributes������������������������������������������������������������������������������������������� 330
Ranges��������������������������������������������������������������������������������������������������������������������������������� 332
Coroutines��������������������������������������������������������������������������������������������������������������������������� 336
std::span������������������������������������������������������������������������������������������������������������������������������ 337
Mathematical Constants������������������������������������������������������������������������������������������������������ 338

xiii
Table of Contents

C++23��������������������������������������������������������������������������������������������������������������������������������������� 339
Multidimensional Subscript Operator���������������������������������������������������������������������������������� 340
Literal Suffixes for size_t����������������������������������������������������������������������������������������������������� 340
The #warning Preprocessor Directive��������������������������������������������������������������������������������� 341
The std::string::contains( ) Member Function���������������������������������������������������������������������� 341
std::print������������������������������������������������������������������������������������������������������������������������������ 343

Chapter 41: Projects��������������������������������������������������������������������������������������������� 347


Project I: Book Inventory����������������������������������������������������������������������������������������������������������� 347
Project II: Book Inventory – Multiple Files��������������������������������������������������������������������������������� 362
Project III: Message Logger������������������������������������������������������������������������������������������������������� 367
Project IV: Message Logger – Multiple Files����������������������������������������������������������������������������� 386
Project V: Information System��������������������������������������������������������������������������������������������������� 392
Project VI: Information System – Multiple Files������������������������������������������������������������������������ 422

Index��������������������������������������������������������������������������������������������������������������������� 433

xiv
About the Author
Slobodan Dmitrović is a software consultant, trainer, and
author of several programming books. He is a professional
R&D software developer with two decades of experience in
the industry. Slobodan provides C++ training courses for
corporate clients and academic institutions. Connect with
Slobodan at https://www.linkedin.com/in/slobodan-
dmitrovic/.

xv
About the Technical Reviewer
Germán González-Morris is a polyglot software architect/
engineer with 20+ years of experience in the field, having
knowledge in Java, Spring, C, Julia, Python, Haskell, and
JavaScript, among others. He works for cloud (architecture)
and web distributed applications. Germán loves math
puzzles (including reading Knuth), swimming, and table
tennis. Also, he has reviewed several books including an
application container book (WebLogic) and books on
languages (C, Haskell, TypeScript, WebAssembly, Math for
coders, regexp, Julia, Algorithms). For more details, you can
visit his blog (https://devwebcl.blogspot.com/) or Twitter
account (@devwebcl).

xvii
Acknowledgments
I want to thank my friends, readers, and fellow C++ peers who have supported me in
writing the second edition of this book.
I am thankful to the entire C++ community for their help and feedback. I would
like to thank Rainer Grimm, Klaus Iglberger, Jens Weller, Bartłomiej Filipek, and
many others.
My most profound appreciation goes to S. Antonijević, Ron and Brankica, and Saša
Popović for their ongoing support.

xix
About the Second Edition
The second edition of this book is updated to include the notable features inside the
C++23 standard.
I have revised and updated numerous chapters with more relevant information and
clarification.
The second edition includes more diagrams to represent certain concepts better.
I have also added the output for all the code snippets.
The book now has a chapter entirely dedicated to various projects.
My intent with the second edition was to provide a simplified, updated, and accurate
introduction to the modern C++ programming language.

xxi
CHAPTER 1

Introduction
Congratulations on choosing to learn the C++ programming language, and thank you for
picking up this book. I will try to introduce you to a beautiful world of C++ to the best of
my abilities.
This book is an effort to introduce the reader to the C++ programming language in
a structured, straightforward, and friendly manner. We will use the “just enough theory
and plenty of examples” approach whenever possible.
To me, C++ is a wonderful product of the human intellect. Over the years, I have
certainly come to think of it as a thing of beauty and elegance. C++ is a language like no
other, surprising in its complexity yet wonderfully sleek and elegant in so many ways. It
is also a language that cannot be learned by guessing, one that is easy to get wrong and
challenging to get right.
In this book, we will get familiar with the language basics first. Then, we will move on
to classes, templates, and the C++ Standard Library. Once we got these covered, we will
describe the modern C++ standards in more detail.
After each section, source code exercises will help us adopt the learned material
more efficiently.
Finally, we will create a couple of source code projects. Let us get started!

1
© Slobodan Dmitrović 2023
S. Dmitrović, Modern C++ for Absolute Beginners, https://doi.org/10.1007/978-1-4842-9274-7_1
CHAPTER 2

What Is C++?
C++ is a programming language – a standardized, general-purpose, object-oriented,
compiled language. Every C++ compiler is accompanied by a set of useful functions
and containers called the C++ Standard Library. Bjarne Stroustrup created C++ as an
extension to a C programming language. Still, C++ evolved to be a completely different
programming language.
Let us emphasize this: C and C++ are two different languages. C++ started as “C with
classes,” but it is now a completely different language. So, C++ is not C; C++ is not C with
classes; it is just C++. And there is no such thing as a C/C++ programming language.
C++ is widely used for so-called systems programming as well as application
programming. C++ is a language that allows us to get down to the metal where we can
perform low-level routines if needed or soar high using abstraction mechanisms such as
templates and classes.

C++ Standards
C++ is governed by the ISO C++ standard. There are multiple ISO C++ standards listed
here in chronological order: C++03, C++11, C++14, C++17, C++20, and the upcoming
C++23 standard.
Every C++ standard, starting with C++11 onward, is referred to as “modern C++.”
And modern C++ is what we will be teaching in this book.

3
© Slobodan Dmitrović 2023
S. Dmitrović, Modern C++ for Absolute Beginners, https://doi.org/10.1007/978-1-4842-9274-7_2
CHAPTER 3

C++ Compilers
C++ programs are usually a collection of some C++ code spread across one or multiple
source and header files. Source files, by convention, have the .cpp extension, and header
files, by convention, have the .h extension. Other extensions are also possible. Both
header and source files are regular text files containing some C++ source code. The C++
compiler is a program that compiles these files and turns them into object files. A linker
then links object files together to create an executable file or a library. At the time of
writing, some of the more popular C++ compilers are

–– The g++ front end (as part of the GNU Compiler Collection or GCC)

–– Visual C++ (as part of the Visual Studio IDE)

–– Clang (as part of the LLVM)

Installing C++ Compilers


The following sections explain how to install C++ compilers on Linux and Windows and
compile and run our C++ programs.

On Linux
To install a C++ compiler (as part of the GCC) on Linux Ubuntu, type the following inside
the terminal:

sudo apt-get install build-essential

To install a C++ compiler on Fedora, we type

sudo dnf install gcc-c++

5
© Slobodan Dmitrović 2023
S. Dmitrović, Modern C++ for Absolute Beginners, https://doi.org/10.1007/978-1-4842-9274-7_3
Chapter 3 C++ Compilers

To compile the C++ source file, named, for example, source.cpp, we type

g++ source.cpp

This command will produce an executable with the default name of a.out. To run the
executable file, type

./a.out

To compile for a C++11 standard, we add the -std=c++11 flag:

g++ -std=c++11 source.cpp

To enable warnings, we add the -Wall flag:

g++ -std=c++11 -Wall source.cpp

To produce a custom executable name, we add the -o flag followed by an


executable name:

g++ -std=c++11 -Wall source.cpp -o myexe

Alternatively, we can install a Clang compiler on Linux Ubuntu by typing

sudo apt-get install clang

To install Clang on Fedora, we type

sudo dnf install clang

The same rules apply to the Clang compiler when compiling. Substitute g++ with
clang++.

On Windows
On Windows, we can install a free or commercial copy of Visual Studio.
Choose Create a new project, make sure the C++ language option is selected, choose
Empty Project, click Next, and click Create. Go to the Solution Explorer panel, right-click
the project name, choose Add ➤ New Item ➤ C++ File (.cpp), type the name of a file
(source.cpp), and click Add. Press F5 to run the program.
We can also do the following: choose Create a new project, make sure the C++
language option is selected, choose Console App, click Next, and click Create.
If a Create a new project button is not visible, choose File ➤ New ➤ Project and repeat
the remaining steps.
6
CHAPTER 4

Our First Program


Let us create a blank text file using the text editor or C++ IDE of our choice and name it
source.cpp. First, let us create an empty C++ program that does nothing. The content of
the source.cpp file is

int main(){}

The function main is the main program’s entry point, the start of our program. When
we run our executable, the code inside the main function body gets executed. A function
is of type int (and returns a result to the system, but let us not worry about that just yet).
The reserved name main is a function name. It is followed by a list of parameters inside
the parentheses () followed by a function body marked with braces {}. Braces marking
the beginning and the end of a function body can also be on separate lines:

int main()
{
}

This simple program does nothing, it has no parameters listed inside parentheses,
and there are no statements inside the function body. It is essential to understand that
this is the main program signature.
There is also another main function signature accepting two different parameters used
for manipulating the command-line arguments. For now, we will only use the first form.

Comments
Single-line comments in C++ start with double slashes //, and the compiler ignores
them. We use them to comment or document the code or use them as notes:

int main()
{

7
© Slobodan Dmitrović 2023
S. Dmitrović, Modern C++ for Absolute Beginners, https://doi.org/10.1007/978-1-4842-9274-7_4
Chapter 4 Our First Program

    // this is a comment


}

We can have multiple single-line comments:

int main()
{
    // this is a comment
    // this is another comment
}

Multiline comments start with the /* and end with the */. They are also known as
C-style comments. Example:

int main()
{
    /* This is a
    multi-line comment */
}

Hello World Example


Now we are ready to get the first glimpse at our “Hello World” example. The following
program is the simplest “Hello World” example. It prints out “Hello World.” in the
console window:

#include <iostream>

int main()
{
    std::cout << "Hello World.";
}

Output:

Hello World.

8
Chapter 4 Our First Program

Believe it or not, this example’s detailed analysis and explanation can be more than
15 pages long. We can go into it right now, but we will be no wiser at this point as we first
need to know what headers, streams, objects, operators, and string literals are. Do not
worry. We will get there.
Explanation:
The #include <iostream> statement includes the iostream header file content into
our source file via the #include directive. The iostream header is part of the standard
library. We need its inclusion to be able to use the std::cout object, also known as the
standard output stream. The << operator, called the stream insertion operator, inserts
our Hello World string literal into that output stream. A string literal is enclosed in
double quotes "". The ; marks the end of the statement. Statements are pieces of the
C++ program that get executed. Statements end with a semicolon ; in C++. The std is
the standard library namespace, and :: is the scope resolution operator. Object cout
is located inside the std namespace, and to access it, we need to prepend the call with
the std::. We will get more familiar with all of these later in the book, especially the
std:: part.
A brief explanation:
In a nutshell, the std::cout << is the natural way of outputting data to the standard
output/console window in C++.
We can output multiple string literals by separating them with multiple << operators:

#include <iostream>

int main()
{
    std::cout << "Some string." << " Another string.";
}

Output:

Some string. Another string.

To output data on a new line, we need to output a newline character \n literal. A


single character literal, including the escape sequence characters in C++, is enclosed in
single quotes '', like 'a', 'B', 'c', '\n', etc.

9
Chapter 4 Our First Program

Example:

#include <iostream>

int main()
{
    std::cout << "First line" << '\n' << "Second line.";
}

Output:

First line
Second line.

Certain characters cannot be easily represented using a single character symbol.


Some character literals start with the \ symbol. The \ represents an escape sequence, a
mechanism to represent certain special characters such as the newline character '\n', a
single quote character '\'', a double quote character '\"', a character '\t', and similar.
Characters can also be part of the single string literal:

#include <iostream>

int main()
{
    std::cout << "First line\nSecond line.";
}

Output:

First line
Second line.

Do not use using namespace std;


Many examples on the Web introduce the entire std namespace into the current
scope via the using namespace std; statement only to be able to type cout instead
of the std::cout. While this might save us from typing five additional characters, it is
wrong for many reasons. We do not want to introduce the entire std namespace into the
current scope because we want to avoid name clashes and ambiguity.

10
Chapter 4 Our First Program

Good to remember Do not introduce the entire std namespace into a current
scope via the using namespace std; statement.

So, instead of this wrong approach:

#include <iostream>

using namespace std; // do not use this

int main()
{
    cout << "Bad practice.";
}

Use the following:

#include <iostream>

int main()
{
    std::cout << "Good practice.";
}

For calls to objects and functions residing inside the std namespace, add the std::
prefix where needed.

11
CHAPTER 5

Types
Every entity has a type. What is a type? A type is a property describing the set of possible
values and operations on those values. Instances of types are called objects. An object is
a region in memory that has a type, a value, and possibly a name. An instance of a simple
type is not to be confused with an instance of a class which is also called an object.

Fundamental Types
C++ has some built-in types. We often refer to them as fundamental types. A declaration
is a statement that introduces a name into a current scope.

Boolean
Let us declare a variable b of type bool. This type holds values of true and false:

int main()
{
    bool b;
}

This example declares a variable b of type bool. And that is it. The variable is not
initialized: and no value has been assigned to it at the time of construction. To initialize a
variable, we use an assignment operator = followed by an initializer:

int main()
{
    bool b = true;
}

13
© Slobodan Dmitrović 2023
S. Dmitrović, Modern C++ for Absolute Beginners, https://doi.org/10.1007/978-1-4842-9274-7_5
Chapter 5 Types

We can also use braces {} for initialization:

int main()
{
    bool b{ true };
}

These examples declare a (local) variable b of type bool and initialize it to a value
of true. Our variable now holds a value of true. All local variables should be initialized.
Accessing uninitialized variables results in undefined behavior, abbreviated as UB. More
on this in the following chapters.

Character Type
Type char, referred to as character type, is used to represent a single character. The type
can store characters such as 'a', 'Z', etc. The size of a character type is exactly one byte.
Character literals are enclosed in single quotes '' in C++. To declare and initialize a
variable of type char, we write

int main()
{
    char c = 'a';
}

Now we can print out the value of our char variable:

#include <iostream>

int main()
{
    char c = 'a';
    std::cout << "The value of variable c is: " << c;
}

Output:

The value of variable c is: a

14
Chapter 5 Types

Once declared and initialized, we can access our variable and change its value:

#include <iostream>

int main()
{
    char c = 'a';
    std::cout << "The value of variable c is: " << c;
    c = 'B';
    std::cout << " The new value of variable c is: " << c;
}

Output:

The value of variable c is: a The new value of variable c is: B

The size of the char type in memory is always one byte. We obtain the size of the type
through a sizeof operator:

#include <iostream>

int main()
{
    std::cout << "The size of type char is: " << sizeof(char) << "
byte(s)";
}

Output:

The size of type char is: 1 byte(s)

There are other character types, such as wchar_t for holding characters of Unicode
character set and char16_t for holding UTF-16 character sets, but for now, let us stick to
the type char.
A character literal is a character enclosed in single quotes, for example, 'a', 'A', 'z',
'X', '0', etc.

15
Chapter 5 Types

Every character is represented by an integer number in the character set. That is why
we can assign both numeric literals (up to a certain number) and character literals to our
char variable:

int main()
{
    char c = 'a';
    // is the same as:
    // char c = 97;
}

We can write char c = 'a'; or we can write char c = 97; which is (probably) the
same, as the 'a' character in the ASCII table is represented with the number of 97. For
the most part, we will be using character literals to represent the value of a char object.

Integer Types
Another fundamental type is int called integer type. We use it to store integral values
(whole numbers), both negative and positive:

#include <iostream>

int main()
{
    int x = 123;
    int y = -256;
    std::cout << "The value of x is: " << x << ", the value of y
is: " << y;
}

Output:

The value of x is: 123, the value of y is: -256

Here, we declared and initialized two variables of type int. The size of int is usually
4 bytes. We can also initialize the variable with another variable. It will receive a copy of
its value. We still have two separate objects in memory:

16
Chapter 5 Types

#include <iostream>

int main()
{
    int x = 123;
    int y = x;
    std::cout << "The value of x is: " << x << ", the value of y
is: " << y;
    // x is 123
    // y is 123
    x = 456;
    std::cout << "The value of x is: " << x << ", the value of y
is: " << y;
    // x is now 456
    // y is still 123
}

Output:

The value of x is: 123, the value of y is: 123The value of x is: 456, the
value of y is: 123

Once we declare a variable, we access and manipulate the variable name by its name
only, without the type name.
Integer literals can be decimal, octal, and hexadecimal. Octal literals start with a
prefix of 0, and hexadecimal literals begin with a prefix of 0x.

int main()
{
    int x = 10;     // decimal literal
    int y = 012;    // octal literal
    int z = 0xA;    // hexadecimal literal
}

All these variables have been initialized to a value of 10 represented by different


integer literals. For the most part, we will be using decimal literals.
There are also other integer types, such as int64_t and others, but we will stick to
int for now.
17
Chapter 5 Types

Floating-Point Types
There are three floating-point types in C++: float, double, and long double. Mainly,
we will be using the type double (double precision). We use it for storing floating-point
values/real numbers:

#include <iostream>

int main()
{
    double d = 3.14;
    std::cout << "The value of d is: " << d;
}

Output:

The value of d is: 3.14

Some of the floating-point literals can be

int main()
{
    double x = 213.456;
    double y = 1.;
    double z = 0.15;
    double w = .15;
    double d = 3.14e10;
}

Type void
Type void is a type with no values. Well, what is the purpose of such a type if we cannot
have objects of that type? Good question. While we cannot have objects of type void, we
can have functions of type void – functions that do not return a value. We can also have
a void pointer type marked with void*. More on this in later chapters when we discuss
pointers and functions.

18
Chapter 5 Types

Type Modifiers
Types can have modifiers. Some of the modifiers are signed and unsigned. The signed
(the default if omitted) means the type can hold both positive and negative values,
and unsigned means the type has unsigned representation. Other modifiers affect the
type’s size: short means the type will have a width of at least 16 bits, and long means
the type will have a width of at least 32 bits. Furthermore, we can now combine these
modifiers:

#include <iostream>

int main()
{
    unsigned long int x = 4294967295;
    std::cout << "The value of an unsigned long integer variable
is: " << x;
}

Output:

The value of an unsigned long integer variable is: 4294967295

Type int is signed by default.

Variable Declaration, Definition, and Initialization


Introducing a name into a current scope is called a declaration. We are letting the world
know there is a name (a variable, for example) of some type from now on in the current
scope. In a declaration, we prepend the variable name with a type name. Declaration
examples:

int main()
{
    char c;
    int x;
    double d;
}

19
Chapter 5 Types

We can declare multiple names on the same line:

int main()
{
    int x, y, z;
}

If there is an initializer for an object present, then we call it an initialization. We


are declaring and initializing an object to a specific value. We can initialize an object in
various ways:

int main()
{
    int x = 123;
    int y{ 123 };
    int z = { 123 };
}

A variable definition is setting a value in memory for a name. The definition is


making sure we can access and use the name in our program. Roughly speaking, it is
a declaration followed by an initialization (for variables) followed by a semicolon. The
definition is also a declaration. Definition examples:

int main()
{
    char c = 'a';
    int x = 123;
    double d = 456.78;
}

20
CHAPTER 6

Exercises
Hello World and Comments
Write a program that has a comment in it and outputs “Hello World.” on one line and
“C++ rocks!” on a new line.

#include <iostream>

int main()
{
    // this is a comment
    std::cout << "Hello World." << '\n';
    std::cout << "C++ rocks!";
}

Output:

Hello World.
C++ rocks!

Declaration
Write a program that declares three variables inside the main function. Variables are of
types char, int, and double. The names of the variables are arbitrary. Since we do not
use any input or output, we do not need to include the <iostream> header.

int main()
{
    char mychar;
21
© Slobodan Dmitrović 2023
S. Dmitrović, Modern C++ for Absolute Beginners, https://doi.org/10.1007/978-1-4842-9274-7_6
Chapter 6 Exercises

    int myint;
    double mydouble;
}

Definition
Write a program that defines three variables inside the main function. The variables are
of types char, int, and double. The names of the variables are arbitrary. The initializers
are arbitrary.

int main()
{
    char mychar = 'a';
    int myint = 123;
    double mydouble = 456.78;
}

Initialization
Write a program that defines three variables inside the main function. The variables are
of types char, int, and double. The names of the variables are arbitrary. The initializers
are arbitrary. The initialization is performed using the initializer list. Print the values
afterward.

#include <iostream>

int main()
{
    char mychar{ 'a' };
    int myint{ 123 };
    double mydouble{ 456.78 };
    std::cout << "The value of a char variable is: " << mychar << '\n';
    std::cout << "The value of an int variable is: " << myint << '\n';
    std::cout << "The value of a double variable is: " << mydouble << '\n';
}

22
Chapter 6 Exercises

Output:

The value of a char variable is: a


The value of an int variable is: 123
The value of a double variable is: 456.78

23
CHAPTER 7

Operators
Assignment Operator
The assignment operator = assigns a value to a variable/object:

int main()
{
    char mychar = 'c';    // define a char variable mychar
    mychar = 'd';         // assign a new value to mychar
    int x = 123;          // define an integer variable x
    x = 456;              // assign a new value to x
    int y = 789;          // define a new integer variable y
    y = x;                // assign a value of x to it
}

Arithmetic Operators
We can do arithmetic operations using arithmetic operators. Some of them are

+ // addition
- // subtraction
* // multiplication
/ // division
% // modulo

Example:

#include <iostream>

int main()
25
© Slobodan Dmitrović 2023
S. Dmitrović, Modern C++ for Absolute Beginners, https://doi.org/10.1007/978-1-4842-9274-7_7
Chapter 7 Operators

{
    int x = 123;
    int y = 456;
    int result = x + y; // addition
    result = x - y; // subtraction
    result = x * y; // multiplication
    result = x / y; // division
    std::cout << "The result is: " << result << '\n';
}

Output:

The result is: 0

The integer division, in our example, results in a value of 0. It is because the result of
the integral division where both operands are integers is truncated toward zeros. In the
expression x / y, x and y are operands, and / is the operator.
If we want a floating-point result, we need to use the type double and make sure at
least one of the division operands is also of type double:

#include <iostream>

int main()
{
    int x = 123;
    double y = 456.0;
    double result = x / y;
    std::cout << "The division result is: " << result << '\n';
}

Output:

The division result is: 0.269737

Similarly, we can have

#include <iostream>

int main()
26
Random documents with unrelated
content Scribd suggests to you:
back
back
back
back
back
back
back
back
back
back
back
back
back
back
back
back
back
back
Welcome to our website – the ideal destination for book lovers and
knowledge seekers. With a mission to inspire endlessly, we offer a
vast collection of books, ranging from classic literary works to
specialized publications, self-development books, and children's
literature. Each book is a new journey of discovery, expanding
knowledge and enriching the soul of the reade

Our website is not just a platform for buying books, but a bridge
connecting readers to the timeless values of culture and wisdom. With
an elegant, user-friendly interface and an intelligent search system,
we are committed to providing a quick and convenient shopping
experience. Additionally, our special promotions and home delivery
services ensure that you save time and fully enjoy the joy of reading.

Let us accompany you on the journey of exploring knowledge and


personal growth!

ebookmass.com

You might also like