C++ All In One For Dummies

Introduction 1

About This Book 1

Foolish Assumptions 4

Icons Used in This Book 4

Beyond the Book 5

Where to Go from Here 6

Book 1: Getting Started with C++ 7

Chapter 1: Configuring Your Desktop System 9

Obtaining a Copy of C++ 20 10

Obtaining Code::Blocks 11

Installing Code::Blocks 12

Working with Windows 12

Working with Mac OS X 13

Using the standard Linux installation 14

Using the graphical Linux installation 15

Touring the Essential Code::Blocks Features 17

Starting Code::Blocks for the first time 18

Opening the sample projects 19

Viewing the essential windows 20

Using Other IDEs 25

Chapter 2: Configuring Your Mobile System 27

Obtaining CppDroid 28

Understanding why CppDroid is such a great choice 29

Getting your copy of CppDroid 31

Ensuring you get a good install 32

Considering Other Alternatives 32

Working with C4Droid 33

Getting multiple language support with AIDE 33

Using web-based IDEs 34

Touring the Essential CppDroid Features 35

Getting started with CppDroid 35

Accessing an example 37

Working with a simple online project 37

Accessing your source code 38

Considering differences with the desktop environment 39

Obtaining CppDroid Help 40

Working with the Help documentation 40

Getting community support 41

Using the free examples 42

Accessing the tutorials 43

Chapter 3: Creating Your First C++ Application 45

Code::Blocks Creating a Project 46

Understanding projects 46

Defining your first project 47

Building and executing your first application 52

Typing the Code 53

Starting with Main 55

Showing Information 55

Doing some math 60

Tabbing your output 66

Let Your Application Run Away 67

Chapter 4: Storing Data in C++ 69

Putting Your Data Places: Variables 70

Creating an integer variable 70

Declaring multiple variables 73

Changing values 74

Setting one variable equal to another 74

Initializing a variable 75

Creating a great name for yourself 76

Manipulating Integer Variables 78

Adding integer variables 78

Subtracting integer variables 82

Multiplying integer variables 84

Dividing integer variables 86

Characters 88

Null character 89

Nonprintable and other cool characters 89

Strings 93

Getting a part of a string 94

Changing part of a string 95

Adding onto a string 96

Adding two strings 97

Making Decisions Using Conditional Operators 98

Telling the Truth with Boolean Variables 100

Reading from the Console 102

Chapter 5: Directing the Application Flow 105

Doing This or Doing That 106

Evaluating Conditions in C++ 107

Finding the right C++ operators 108

Combining multiple evaluations 110

Including Evaluations in C++ Conditional Statements 111

Deciding what if and also what else 112

Going further with the else and if 113

Repeating Actions with Statements That Loop 115

Understanding how computers use loops 116

Looping situations 116

Looping for 117

Performing a simple for loop 118

Using multiple initialization variables 123

Working with ranges 126

Placing a condition within the declaration 128

Letting C++ determine the type 129

Looping while 130

Doing while 132

Breaking and continuing 133

Breaking 134

Continuing 135

Nesting loops 136

Chapter 6: Dividing Your Work with Functions 139

Dividing Your Work 139

Calling a Function 144

Passing a variable 146

Passing multiple variables 147

Writing Your Own Functions 148

Defining the AddOne() function 149

Seeing how AddOne() is called 150

Taking the AddOne() Function apart 150

Considering the AddOne() parameter 151

Understanding the AddOne() name and type 152

Improving On the Basic Function 153

Using multiple parameters or no parameters 153

Returning nothing 156

Keeping your variables local 157

Forward references and function prototypes 159

Writing two versions of the same function 161

Calling All String Functions 163

Inserting a string into a string 163

Removing parts of a string 164

Replacing parts of a string 164

Using the string functions together 164

Understanding main() 165

Chapter 7: Splitting Up Source Code Files 169

Creating Multiple Source Files 170

Adding a new source code file 170

Removing an existing source code file 173

Creating a project with multiple existing files 173

Getting multiple files to interact 177

Sharing with Header Files 179

Adding the header only once 182

Using angle brackets or quotes 182

Sharing Variables among Source Files 183

Using the Mysterious Header Wrappers 185

Chapter 8: Referring to Your Data Through Pointers 187

Understanding the Changes in Pointers for C++ 20 188

Avoiding broken code 188

Considering the issues 189

Writing cleaner and less bug-prone code 191

Heaping and Stacking the Variables 192

Getting a variable’s address 196

Changing a variable by using a pointer 198

Pointing at a string 200

Pointing to something else 203

Tips on pointer variables 204

Creating New Raw Pointers 205

Using new 206

Using an initializer 208

Freeing Raw Pointers 209

Working with Smart Pointers 211

Creating smart pointers using std::unique_ptr and std::shared_ptr 212

Defining nullable values using std::optional and std::nullopt 216

Passing Pointer Variables to Functions 218

Returning Pointer Variables from Functions 221

Part 2: Understanding Objects and Classes 225

Chapter 1: Working with Classes 227

Understanding Objects and Classes 227

Classifying classes and objects 230

Describing methods and data 231

Implementing a class 232

Separating method code 237

The parts of a class 240

Working with a Class 241

Accessing members 241

Using classes and raw pointers 244

Using classes and smart pointers 248

Passing objects to functions 249

Using const parameters in functions 251

Using the this pointer 252

Overloading methods 256

Starting and Ending with Constructors and Destructors 259

Starting with constructors 259

Ending with destructors 260

Sampling constructors and destructors 260

Adding parameters to constructors 263

Building Hierarchies of Classes 264

Creating a hierarchy in C++ 265

Understanding types of inheritance 266

Creating and Using Object Aliases 267

Chapter 2: Using Advanced C++ Features 269

Filling Your Code with Comments 270

Converting Types 272

Understanding how int and string conversions work 272

Seeing int and string conversions in action 273

Considering other conversion issues 276

Reading from the Console 277

Understanding Preprocessor Directives 282

Understanding the basics of preprocessing 282

Creating constants and macros with #define 283

Performing conditional compilation 286

Exercising the basic preprocessor directives 288

Using Constants 292

Using Switch Statements 295

Supercharging enums with Classes 298

Working with Random Numbers 300

Storing Data in Arrays 302

Declaring and accessing an array 303

Arrays of pointers 304

Passing arrays to functions 306

Adding and subtracting pointers 307

Chapter 3: Planning and Building Objects 309

Recognizing Objects 310

Observing the Mailboxes class 312

Observing the Mailbox class 314

Finding other objects 315

Encapsulating Objects 316

Considering the Application Programming Interface 316

Understanding properties 316

Choosing between private and protected 318

Defining a process 318

Implementing properties 319

Building Hierarchies 322

Establishing a hierarchy 322

Protecting members when inheriting 324

Overriding methods 330

Specializing with polymorphism 332

Getting abstract about things 333

Chapter 4: Building with Design Patterns 335

Delving Into Pattern History 336

Introducing a Simple Pattern: the Singleton 337

Using an existing pattern 337

Creating a singleton pattern class 338

Watching an Instance with an Observer 341

Understanding the observer pattern 341

Defining an observer pattern class 343

Observers and the Standard C++ Library 346

Automatically adding an observer 347

Mediating with a Pattern 349

Defining the mediator pattern scenario 350

Outlining the car example 351

Creating the car example 354

Book 3: Understanding Functional Programming 367

Chapter 1: Considering Functional Programming 369

Understanding How Functional Programming Differs 370

Defining an Impure Language 373

Considering the requirements 373

Understanding the C++ functional limitations 374

Seeing Data as Immutable 375

Working with immutable variables 376

Working with immutability in classes and structures 377

Creating constant expressions 378

Considering the Effects of State 381

Eliminating Side Effects 382

Contrasting declarations and functions 383

Associating functions with side effects 384

Removing side effects 385

Creating a declarative C++ example 387

Understanding the Role of auto 388

Passing Functions to Functions 390

Seeing a simple example of function input 391

Using transforms 393

Using Lambda Expressions for Implementation 394

Chapter 2: Working with Lambda Expressions 397

Creating More Readable and Concise C++ Code 398

Defining the Essential Lambda Expression 399

Defining the parts of a lambda expression 399

Relying on computer detection of return type 401

Using the auto keyword with lambda expressions 404

Using lambda expressions as macros 405

Developing with Lambda Expressions 406

Using lambda expressions with classes and structures 407

Working with the capture clause 408

Sorting data using a lambda expression 411

Specifying that the lambda expression throws exceptions 413

Chapter 3: Advanced Lambda Expressions 415

Considering the C++ 20 Lambda Extensions 416

Defining an immediate function 416

Using = and this in captures 417

Finding other changes 418

Working in Unevaluated Contexts 418

Using Assignable Stateless Lambda Expressions 420

Dealing with Pack Expansions 422

Considering the template 422

Processing the variables using recursion 423

Processing the variables using a lambda expression 424

Book 4: Fixing Problems 427

Chapter 1: Dealing with Bugs 429

It’s Not a Bug It’s a Feature! 430

Make Your Application Features Look Like Features 431

Anticipating (Almost) Everything 432

Considering menus 432

Dealing with textual input 435

Performing string processing 437

Avoiding Mistakes, Plain and Simple 441

Chapter 2: Debugging an Application 443

Programming with Debuggers 444

Running the debugger 446

Recognizing the parts of the Code::Blocks debugger 453

Debugging with Different Tools 455

Debugging a Code::Blocks Application with Command-Line Arguments 456

Chapter 3: Stopping and Inspecting Your Code 457

Setting and Disabling Breakpoints 458

Setting a breakpoint in Code::Blocks 459

Enabling and disabling breakpoints 460

Watching, Inspecting, and Changing Variables 463

Watching the variables 465

Changing values 466

Chapter 4: Traveling About the Stack 469

Stacking Your Data 470

Moving about the stack 471

Storing local variables 473

Debugging with Advanced Features 475

Viewing threads 475

Tracing through assembly code 475

Book 5: Advanced Programming 479

Chapter 1: Working with Arrays, Pointers, and References 481

Building Up Arrays 482

Declaring arrays 482

Arrays and pointers 484

Using multidimensional arrays 488

Arrays and command-line parameters 492

Allocating an array on the heap 494

Deleting an array from the heap 494

Storing arrays of pointers and arrays of arrays 495

Building constant arrays 498

Pointing with Pointers 498

Becoming horribly complex 499

Pointers to functions 505

Pointing a variable to a method 506

Pointing to static methods 509

Referring to References 510

Reference variables 510

Returning a reference from a function 511

Chapter 2: Creating Data Structures 515

Working with Data 515

The great variable roundup 516

Expressing variables from either side 518

Casting a spell on your data 520

Comparing casting and converting 521

Casting safely with C++ 523

Structuring Your Data 529

Structures as component data types 531

Equating structures 531

Returning compound data types 532

Naming Your Space 534

Creating a namespace 534

Employing using namespace 535

Using variables 537

Using part of a namespace 538

Chapter 3: Constructors, Destructors, and Exceptions 541

Constructing and Destructing Objects 542

Overloading constructors 542

Initializing members 543

Adding a default constructor 548

Functional constructors 550

Calling one constructor from another 553

Copying instances with copy constructors 555

When constructors go bad 557

Destroying your instances 558

Virtually inheriting destructors 560

Programming the Exceptions to the Rule 563

Creating a basic try catch block 563

Using multiple catch blocks 565

Throwing direct instances 566

Catching any exception 567

Rethrowing an exception 568

Using a standard category 570

Chapter 4: Advanced Class Usage 571

Inherently Inheriting Correctly 572

Morphing your inheritance 572

Avoiding polymorphism 573

Adjusting access 574

Avoiding variable naming conflicts 575

Using class-based access adjustment 576

Returning something different, virtually speaking 577

Multiple inheritance 581

Virtual inheritance 584

Friend classes and functions 588

Using Classes and Types within Classes 591

Nesting a class 591

Types within classes 597

Chapter 5: Creating Classes with Templates 601

Templatizing a Class 602

Considering types 602

Defining the need for templates 602

Creating and using a template 605

Understanding the template keyword 607

Going Beyond the Basics 609

Separating a template from the function code 609

Including static members in a template 611

Parameterizing a Template 612

Putting different types in the parameter 613

Including multiple parameters 616

Working with non-type parameters 619

Typedefing a Template 622

Deriving Templates 623

Deriving classes from a class template 623

Deriving a class template from a class 626

Deriving a class template from a class template 627

Templatizing a Function 630

Overloading and function templates 632

Templatizing a method 635

Chapter 6: Programming with the Standard Library 637

Architecting the Standard Library 638

Containing Your Classes 638

Storing in a vector 639

Working with std::array 642

Mapping your data 643

Containing instances, pointers, or references 644

Working with copies 648

Comparing instances 649

Iterating through a container 655

A map of pairs in your hand 658

The Great Container Showdown 658

Associating and storing with a set 658

Unionizing and intersecting sets 662

Listing with list 664

Stacking the deque 669

Waiting in line with stacks and queues 670

Copying Containers 673

Creating and Using Dynamic Arrays 675

Working with Unordered Data 677

Using std::unordered_set to create an unordered set 677

Manipulating unordered sets 677

Working with Ranges 679

Book 6: Reading and Writing Files 681

Chapter 1: Filing Information with the Streams Library 683

Seeing a Need for Streams 684

Programming with the Streams Library 686

Getting the right header file 686

Opening a file 687

Reading from a file 690

Reading and writing a file 691

Working with containers 692

Handling Errors When Opening a File 693

Flagging the ios Flags 695

Chapter 2: Writing with Output Streams 697

Inserting with the << Operator 698

Formatting Your Output 699

Formatting with flags 700

Specifying a precision 704

Setting the width and creating fields 707

Chapter 3: Reading with Input Streams 711

Extracting with Operators 712

Encountering the End of File 715

Using the record count approach 715

Using the EOF check approach 718

Reading Various Types 720

Understanding data reading issues 720

Writing and reading string-type data 721

Writing and reading structured data 724

Chapter 4: Building Directories and Contents 727

Manipulating Directories 728

Creating a directory 728

Deleting a directory 730

Getting the Contents of a Directory 731

Copying Files 733

Copying with windows 734

Using the quick-and-dirty method 734

Moving and Renaming Files and Directories 735

Chapter 5: Streaming Your Own Classes 737

Streaming a Class for Text Formatting 738

Understanding the process 739

Considering the insertion implementation 739

Considering the extraction implementation 741

Manipulating a Stream 742

What’s a manipulator? 742

Writing your own manipulator 744

Book 7: Advanced Standard Library Usage 751

Chapter 1: Exploring the Standard Library Further 753

Considering the Standard Library Categories 755

Algorithms 755

Atomic operations 757

C Compatibility 759

Concepts 759

Containers 760

Coroutines 760

Filesystem 761

Input/Output 761

Iterators 761

Localization 763

Numerics 763

Ranges 764

Regular Expressions 766

Strings 766

Thread Support 767

Utilities 767

Parsing Strings Using a Hash 768

Obtaining Information Using a Random Access Iterator 771

Locating Values Using the Find Algorithm 774

Using the Random Number Generator 776

Working with Temporary Buffers 777

Chapter 2: Working with User-Defined Literals (UDLs) 779

Understanding the Need for UDLs 780

Prefixes and suffixes 781

Differentiating between raw and cooked 784

Working with the UDLs in the Standard Library 785

std::basic_string 785

std::complex 788

std::chrono::duration 789

Creating Your Own UDLs 791

Developing a conversion UDL 792

Developing a custom type UDL 793

Using a custom UDL for side effects 794

Chapter 3: Building Original Templates 795

Deciding When to Create a Template 796

Defining the Elements of a Good Template 797

Creating a Basic Math Template 799

Building a Structure Template 801

Developing a Class Template 804

Considering Template Specialization 807

Creating a Template Library 809

Defining the library project 810

Configuring the library project 812

Coding the library 813

Using Your Template Library 815

Chapter 4: Investigating Boost 817

Considering the Standard Library Alternative 818

Understanding why the Standard Library contains Boost features 818

Defining the trade-offs of using the Standard Library 819

Understanding Boost 820

Boost features 821

Licensing 822

Paid support 823

Obtaining and Installing Boost for Code::Blocks 823

Unpacking Boost 823

Using the header-only libraries 825

Building the libraries 825

Testing the installation 827

Creating the Boost Tools 833

Using Boost.Build 836

Getting a successful build 836

Creating your own example 836

Using Inspect 837

Understanding BoostBook 840

Using QuickBook 841

Using bcp 843

Using Wave 845

Building Your First Boost Application Using Date Time 846

Chapter 5: Boosting up a Step 849

Parsing Strings Using RegEx 850

Adding the RegEx library 851

Creating the RegEx code 855

Breaking Strings into Tokens Using Tokenizer 857

Performing Numeric Conversion 858

Creating Improved Loops Using Foreach 862

Accessing the Operating System Using Filesystem 864

Index 869