C++ all-in-one for dummies / John Paul Mueller.

Format:

Book

Author/Creator:

Mueller, John, 1958- author.

Language:

English

Subjects (All):

C++ (Computer program language).

Physical Description:

1 online resource (915 pages) : illustrations

Edition:

Fourth edition.

Place of Publication:

Hoboken, New Jersey : John Wiley & Sons, Incorporated, [2021]

Summary:

Get ready for C++20 with all you need to know for complete mastery! Your comprehensive and updated guide to one of the world's most popular programming languages is here! Whether you're a novice or expert, you'll find what you need to get going with the latest features of C++20. The workhorse of programming languages, C++ gives you the utmost control of data usage and interface and resource allocation. If your job involves data, proficiency in C++ means you're indispensable! This edition gives you 8 books in 1 for total C++ mastery. Inside, internationally renowned expert John Paul Mueller takes you from the fundamentals of working with objects and classes to writing applications that use paradigms not normally associated with C++, such as those used for functional programming strategies. The book also includes online resources such as source code. You discover how to use a C++ GNU compiler to build applications and even how to use your mobile device for coding. Conquer advanced programming and troubleshooting Streamline your code with lambda expressions Use C++ where you need it: for gaming, enterprise applications, and Web services Uncover object secrets including the use of design patterns Discover how to use functional programming techniques to make code concise and easy to read If you want to be your organization's C++ guru, C++ All-In-One for Dummies is where it's at!.

Contents:

Intro

Title Page

Copyright Page

Table of Contents

Introduction

About This Book

Foolish Assumptions

Icons Used in This Book

Beyond the Book

Where to Go from Here

Book 1 Getting Started with C++

Chapter 1 Configuring Your Desktop System

Obtaining a Copy of C++ 20

Obtaining Code::Blocks

Installing Code::Blocks

Working with Windows

Working with Mac OS X

Using the standard Linux installation

Using the graphical Linux installation

Touring the Essential Code::Blocks Features

Starting Code::Blocks for the first time

Opening the sample projects

Viewing the essential windows

Using Other IDEs

Chapter 2 Configuring Your Mobile System

Obtaining CppDroid

Understanding why CppDroid is such a great choice

Getting your copy of CppDroid

Ensuring you get a good install

Considering Other Alternatives

Working with C4Droid

Getting multiple language support with AIDE

Using web-based IDEs

Touring the Essential CppDroid Features

Getting started with CppDroid

Accessing an example

Working with a simple online project

Accessing your source code

Considering differences with the desktop environment

Obtaining CppDroid Help

Working with the Help documentation

Getting community support

Using the free examples

Accessing the tutorials

Chapter 3 Creating Your First C++ Application

Code::Blocks Creating a Project

Understanding projects

Defining your first project

Building and executing your first application

Typing the Code

Starting with Main

Showing Information

Doing some math

Tabbing your output

Let Your Application Run Away

Chapter 4 Storing Data in C++

Putting Your Data Places: Variables

Creating an integer variable

Declaring multiple variables

Changing values

Setting one variable equal to another.

Initializing a variable

Creating a great name for yourself

Manipulating Integer Variables

Adding integer variables

Subtracting integer variables

Multiplying integer variables

Dividing integer variables

Characters

Null character

Nonprintable and other cool characters

Strings

Getting a part of a string

Changing part of a string

Adding onto a string

Adding two strings

Making Decisions Using Conditional Operators

Telling the Truth with Boolean Variables

Reading from the Console

Chapter 5 Directing the Application Flow

Doing This or Doing That

Evaluating Conditions in C++

Finding the right C++ operators

Combining multiple evaluations

Including Evaluations in C++ Conditional Statements

Deciding what if and also what else

Going further with the else and if

Repeating Actions with Statements That Loop

Understanding how computers use loops

Looping situations

Looping for

Performing a simple for loop

Using multiple initialization variables

Working with ranges

Placing a condition within the declaration

Letting C++ determine the type

Looping while

Doing while

Breaking and continuing

Breaking

Continuing

Nesting loops

Chapter 6 Dividing Your Work with Functions

Dividing Your Work

Calling a Function

Passing a variable

Passing multiple variables

Writing Your Own Functions

Defining the AddOne() function

Seeing how AddOne() is called

Taking the AddOne() Function apart

Considering the AddOne() parameter

Understanding the AddOne() name and type

Improving On the Basic Function

Using multiple parameters or no parameters

Returning nothing

Keeping your variables local

Forward references and function prototypes

Writing two versions of the same function

Calling All String Functions.

Inserting a string into a string

Removing parts of a string

Replacing parts of a string

Using the string functions together

Understanding main()

Chapter 7 Splitting Up Source Code Files

Creating Multiple Source Files

Adding a new source code file

Removing an existing source code file

Creating a project with multiple existing files

Getting multiple files to interact

Sharing with Header Files

Adding the header only once

Using angle brackets or quotes

Sharing Variables among Source Files

Using the Mysterious Header Wrappers

Chapter 8 Referring to Your Data Through Pointers

Understanding the Changes in Pointers for C++ 20

Avoiding broken code

Considering the issues

Writing cleaner and less bug-prone code

Heaping and Stacking the Variables

Getting a variable's address

Changing a variable by using a pointer

Pointing at a string

Pointing to something else

Tips on pointer variables

Creating New Raw Pointers

Using new

Using an initializer

Freeing Raw Pointers

Working with Smart Pointers

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

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

Passing Pointer Variables to Functions

Returning Pointer Variables from Functions

Book 2 Understanding Objects and Classes

Chapter 1 Working with Classes

Understanding Objects and Classes

Classifying classes and objects

Describing methods and data

Implementing a class

Separating method code

The parts of a class

Working with a Class

Accessing members

Using classes and raw pointers

Using classes and smart pointers

Passing objects to functions

Using const parameters in functions

Using the this pointer

Overloading methods

Starting and Ending with Constructors and Destructors.

Starting with constructors

Ending with destructors

Sampling constructors and destructors

Adding parameters to constructors

Building Hierarchies of Classes

Creating a hierarchy in C++

Understanding types of inheritance

Creating and Using Object Aliases

Chapter 2 Using Advanced C++ Features

Filling Your Code with Comments

Converting Types

Understanding how int and string conversions work

Seeing int and string conversions in action

Considering other conversion issues

Understanding Preprocessor Directives

Understanding the basics of preprocessing

Creating constants and macros with #define

Performing conditional compilation

Exercising the basic preprocessor directives

Using Constants

Using Switch Statements

Supercharging enums with Classes

Working with Random Numbers

Storing Data in Arrays

Declaring and accessing an array

Arrays of pointers

Passing arrays to functions

Adding and subtracting pointers

Chapter 3 Planning and Building Objects

Recognizing Objects

Observing the Mailboxes class

Observing the Mailbox class

Finding other objects

Encapsulating Objects

Considering the Application Programming Interface

Understanding properties

Choosing between private and protected

Defining a process

Implementing properties

Building Hierarchies

Establishing a hierarchy

Protecting members when inheriting

Overriding methods

Specializing with polymorphism

Getting abstract about things

Chapter 4 Building with Design Patterns

Delving Into Pattern History

Introducing a Simple Pattern: the Singleton

Using an existing pattern

Creating a singleton pattern class

Watching an Instance with an Observer

Understanding the observer pattern

Defining an observer pattern class.

Observers and the Standard C++ Library

Automatically adding an observer

Mediating with a Pattern

Defining the mediator pattern scenario

Outlining the car example

Creating the car example

Book 3 Understanding Functional Programming

Chapter 1 Considering Functional Programming

Understanding How Functional Programming Differs

Defining an Impure Language

Considering the requirements

Understanding the C++ functional limitations

Seeing Data as Immutable

Working with immutable variables

Working with immutability in classes and structures

Creating constant expressions

Considering the Effects of State

Eliminating Side Effects

Contrasting declarations and functions

Associating functions with side effects

Removing side effects

Creating a declarative C++ example

Understanding the Role of auto

Passing Functions to Functions

Seeing a simple example of function input

Using transforms

Using Lambda Expressions for Implementation

Chapter 2 Working with Lambda Expressions

Creating More Readable and Concise C++ Code

Defining the Essential Lambda Expression

Defining the parts of a lambda expression

Relying on computer detection of return type

Using the auto keyword with lambda expressions

Using lambda expressions as macros

Developing with Lambda Expressions

Using lambda expressions with classes and structures

Working with the capture clause

Sorting data using a lambda expression

Specifying that the lambda expression throws exceptions

Chapter 3 Advanced Lambda Expressions

Considering the C++ 20 Lambda Extensions

Defining an immediate function

Using = and this in captures

Finding other changes

Working in Unevaluated Contexts

Using Assignable Stateless Lambda Expressions

Dealing with Pack Expansions

Considering the template.

Processing the variables using recursion.

Notes:

Includes index.

Description based on print version record.

Description based on publisher supplied metadata and other sources.

ISBN:

9781119601739

1119601738

9781119601753

1119601754

OCLC:

1256681626

Publisher Number:

9781119601746