C++ for Dummies.

Format:

Book

Author/Creator:

Jones, Bradley L.

Language:

English

Physical Description:

1 online resource (515 pages)

Edition:

8th ed.

Place of Publication:

Newark : John Wiley & Sons, Incorporated, 2026.

Summary:

An accessible walkthrough of one of the world's most popular programming languages: C++ C++ For Dummies is your from-scratch guide that explains the essentials of what you need to know to understand the language and build your very first program in C++.

Contents:

Intro

Title Page

Copyright Page

Table of Contents

Introduction

About This Book

Conventions Used in this Book

Be Aware: This Is a Modern C++ Book

Icons Used in This Book

Beyond the Book

Where to Go from Here

Part 1 Getting Started with C++ Programming

Chapter 1 Writing Your First C++ Program

Grasping C++ Concepts

Installing Code::Blocks

Microsoft Windows

Ubuntu Linux

Installing gcc

Macintosh

Installing Xcode

Installing a development tool to use C++

Creating Your First C++ Program

Creating a project

Entering the C++ code

Cheating

Building your program

Executing Your Program

Reviewing the Annotated Program

Examining the framework for all C++ programs

Clarifying source code with comments

Basing programs on C++ statements

Writing declarations

Generating output

Calculating Expressions

Storing the results of an expression

Examining the remainder of Conversion

And Now, a Few Comments on C++26

Chapter 2 Storing Stuff in Variables

Declaring Variables

Declaring Different Types of Variables

Not all numbers are the same

Reviewing the limitations of integers in C++

Integer round-off

Limited range

Solving the truncation problem

Looking at the limits of floating-point numbers

Counting

Calculation speed

Loss of accuracy

Not-so-limited range

Declaring Variable Types

Types of constants

Range of numeric types

Special characters

Carrying Wide Loads on the char Highway

Automatic Declarations

Chapter 3 Doing the Math

Performing Simple Binary Arithmetic

Decomposing Expressions

Determining the Order of Operations

Performing Unary Operations

Using Assignment Operators

Chapter 4 Show Me the Good Stuff!

The Old versus the New

Printing the Old Way.

A note about streaming

While I'm at it: Getting user input

Printing special characters

Printing the Modern Way

Simple printing

Printing variables

Adding a little bit of formatting

The Pros and Cons of the Old Ways Versus the New

Make It Stop!

Chapter 5 Performing Logical Operations

Why Mess with Logical Operations?

Using the Simple Comparison Operators

Storing logical values

Using logical int variables

Performing logical operations (carefully!) on floating-point variables

Adding Logic with the Logical Operators

Making complex decisions

Short circuits and C++

Streamlining with the Three-Way Comparison Operator

Peeking at the Bitwise Logical Operations

Chapter 6 Controlling the Flow

Controlling Program Flow with the Branch Commands

Executing Loops in a Program

Looping while a condition is true

Using the autoincrement/autodecrement feature

Using the for loop

Avoiding the dreaded infinite loop

For each his own

Applying special loop controls

Nesting Control Commands

Switching to a Different Subject?

Part 2 Becoming a Functional C++ Programmer

Chapter 7 Creating Functions

Writing and Using a Function

Exploring Functions

Choosing not to respond

Understanding simple functions

Writing functions

Understanding Functions with Arguments

Functions with arguments

Functions with multiple arguments

main() exposed

Overloading Function Names

Defining Function Prototypes

Defaulting Arguments

Passing by Value and Passing by Reference

Understanding a Variable's Visibility

Benefiting from Functions

Chapter 8 Grouping Similar Things Together Using Arrays

Making the Case for Arrays

Using an Array

Initializing an array

Accessing too far into an array

Arraying range-based for loops

A safer way to use arrays.

Using Arrays of Characters

Creating an array of characters

Creating a string of characters

Manipulating Strings with Character

Defining and Using Arrays of Arrays

Using the Array Library Functions

And Now the Bad News, Which Is Actually Good News

Buffer Overflow: Overfilling Your Arrays

Avoiding buffer overflow

Checking out a better way to avoid buffer overflow

Making Room for Wide Strings

Chapter 9 Taking a First Look at C++ Pointers

What's in an Address?

Addressing Address Operators

Using Pointer Variables

Passing Pointers to Functions

Passing by value

Passing pointer values

Passing by reference

Constant const Irritation

Returning a Pointer from a Function

Defining limited scope

Examining the scope problem

Using Pointers and Allocating Memory for Variables

Making Life Safe with Smart Pointers

Pointing to an array

Keeping your pointer to yourself

Using New Even Though It's Now Old

Chapter 10 Taking a Second Look at C++ Pointers

Performing Operations on Pointer Variables

Reexamining arrays in light of pointer variables

Applying operators to the address of an array

Expanding pointer operations to a string

Applying operators to pointer types other than char

Contrasting a pointer with an array

Declaring and Using Arrays of Pointers

Utilizing arrays of character strings

Accessing the arguments to main()

Accessing program arguments, DOS-style

Chapter 11 Using the C++ Preprocessor

What Is a Preprocessor?

#Defining Things

Okay, how about not defining things?

A better way to define things

Enumerating other options

Including Things #if I Say So

Intrinsically Defined Objects

Using Using and Typedef

#Including Files

Organizing with Modules

Why modules are better

Creating a module

Using a module.

Compiling your app that uses a module

One More Concept to Cover

Part 3 Giving Your Program a Bit of Class

Chapter 12 Examining Object-Oriented Programming

Abstracting Microwave Ovens

Preparing functional nachos

Preparing object-oriented nachos

Classifying Microwave Ovens

Why Classify?

A Few Other Thoughts on OOP

Chapter 13 Adding Class to C++

Formatting a Class

Accessing the Members of a Class

Activating Our Objects

Simulating real-world objects

Why bother with member functions?

Adding a Member Function

Calling a Member Function

Accessing Other Members from a Member Function

Scope Resolution (and I Don't Mean How Well Your Telescope Works)

Defining a Member Function in the Class

Keeping a Member Function after Class

Overloading Member Functions

Holding a Class in Public: Using Structs

Nesting Structs and Classes

Chapter 14 Separating Letters from Words: Character Arrays versus Strings

Distinguishing Between a String and an Array of Characters

The String Container

Tapping into Your Library of String Functions

Gaining a New View of Strings

Taking a Deeper Dive into Formatting

Adding modifiers to your formatting

But wait! Why not just printIn(line)?

Changing Numbers to Strings

Chapter 15 Pointing and Staring at Objects

Declaring Arrays of Objects

Declaring Pointers to Objects

Dereferencing an object pointer

Pointing toward arrow pointers

Passing Objects to Functions

Calling a function with an object value

Calling a function with an object pointer

Calling a function by using the reference operator

Why Bother with Pointers or References?

Returning to the Heap

Allocating heaps of objects

When memory is allocated for you

Linking Up with Linked Lists

Performing other operations on a linked list.

Hooking up with a LinkedListData program

A difference between unique and shared pointers

Ray of Hope: A List of Containers Linked to the C++ Library

Chapter 16 Protecting Members: Do Not Disturb

Making Members Private

Why you need private members

Discovering how private members work

Making an Argument for Using Private Members

Protecting the internal state of the class

Using a class with a limited interface

Getting and setting data members

Getting Friendly with Your Private Members

Chapter 17 "Why Do You Build Me Up, Just to Tear Me Down, Baby?"

Creating Objects

Using Constructors

Constructing a single object

Constructing multiple objects

Constructing a duplex

Dissecting a Destructor

Why you need the destructor

Working with destructors

Smart Pointers, Deleting, and Destruction - Oh, My!

Chapter 18 Making Constructive Arguments

Outfitting Constructors with Arguments

Placing Too Many Demands on the Carpenter: Overloading the Constructor

Sometimes, defaulting is good

Sometimes, using someone else's code is okay

Defaulting default Constructors

Constructing Class Members

Constructing a complex data member

Calling class data member constructors

Combining this with member initialization

Constructing a constant data member

Reconstructing the Order of Construction

Local objects construct in order

Static objects construct only once

All global objects construct before main()

Global objects construct in no particular order

Members construct in the order in which they are declared

Destructors destruct in the reverse order of the constructors

Constructing Arrays

Constructors as a Form of Conversion

Ignore That Value, Please

Chapter 19 Making Copies with the Copy/Move Constructor

Copying an Object

Why you need the copy constructor.

Using the copy constructor.

Notes:

Description based on publisher supplied metadata and other sources.

ISBN:

1-394-38048-8

9781394380480

OCLC:

1586549340