(Ebook) C++ for Dummies 7th Edition by Stephen Randy Davis ISBN 9781118823774 111882377X

(Ebook) C++ for Dummies 7th Edition by Stephen Randy Davis ISBN 9781118823774 111882377X

(Ebook) C++ for Dummies 7th Edition by Stephen Randy Davis - Ebook PDF Instant Download/Delivery: 9781118823774 ,111882377X
Full download (Ebook) C++ for Dummies 7th Edition after payment

Product details:

ISBN 10: 111882377X
ISBN 13: 9781118823774
Author: Stephen Randy Davis

The best-selling C++ For Dummies book makes C++ easier!

C++ For Dummies, 7^th Edition is the best-selling C++ guide on the market, fully revised for the 2014 update. With over 60% new content, this updated guide reflects the new standards, and includes a new Big Data focus that highlights the use of C++ among popular Big Data software solutions. The book provides step-by-step instruction from the ground up, helping beginners become programmers and allowing intermediate programmers to sharpen their skills. The companion website provides all code mentioned in the text, an updated GNU_C++, the new C++ compiler, and other applications. By the end of the first chapter, you will have programmed your first C++ application!

As one of the most commonly used programming languages, C++ is a must-have skill for programmers who wish to remain versatile and marketable. C++ For Dummies, 7^th Edition provides clear, concise, expert instruction, which is organized for easy navigation and designed for hands-on learning. Whether you're new to programming, familiar with other languages, or just getting up to speed on the new libraries, features, and generics, this guide provides the information you need.

• Provides you with an introduction to C++ programming
• Helps you become a functional programmer
• Features information on classes, inheritance, and optional features
• Teaches you 10 ways to avoid adding bugs

The book incorporates the newest C++ features into the fundamental instruction, allowing beginners to learn the update as they learn the language. Staying current on the latest developments is a crucial part of being a programmer, and C++ For Dummies, 7^th Edition gets you started off on the right foot.

(Ebook) C++ for Dummies 7th Edition Table of contents:

Part I: Getting Started with C++ Programming

Chapter 1: Writing Your First C++ Program

Grasping C++ Concepts

Installing Code::Blocks

Windows

Ubuntu Linux

Macintosh

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

Chapter 2: Declaring Variables Constantly

Declaring Variables

Declaring Different Types of Variables

Reviewing the limitations of integers in C++

Solving the truncation problem

Looking at the limits of floating point numbers

Declaring Variable Types

Types of constants

Range of Numeric Types

Special characters

Wide Loads on Char Highway

Are These Calculations Really Logical?

Mixed Mode Expressions

Automatic Declarations

Chapter 3: Performing Mathematical Operations

Performing Simple Binary Arithmetic

Decomposing Expressions

Determining the Order of Operations

Performing Unary Operations

Using Assignment Operators

Chapter 4: Performing Logical Operations

Why Mess with Logical Operations?

Using the Simple Logical Operators

Storing logical values

Using logical int variables

Be careful performing logical operations on floating-point variables

Expressing Binary Numbers

The decimal number system

Other number systems

The binary number system

Performing Bitwise Logical Operations

The single-bit operators

Using the bitwise operators

A simple test

Chapter 5: Controlling Program 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 II: Becoming a Functional C++Programmer

Chapter 6: Creating Functions

Writing and Using a Function

Defining our first function

Defining the sumSequence() function

Calling the function sumSequence()

Divide and conquer

Understanding the Details of Functions

Understanding simple functions

Understanding functions with arguments

Overloading Function Names

Defining Function Prototypes

Defaulting Arguments

Passing by Value and Passing by Reference

Variable Storage Types

Chapter 7: Storing Sequences in Arrays

Arraying the Arguments for Arrays

Using an array

Initializing an array

Accessing too far into an array

Arraying range-based for loops

Defining and using arrays of arrays

Using Arrays of Characters

Creating an array of characters

Creating a string of characters

Manipulating Strings with Character

Adding Some Library Functions

Making Room for Wide Strings

Chapter 8: Taking a First Look at C++ Pointers

Variable Size

What’s in an Address?

Address Operators

Using Pointer Variables

Using different types of pointers

Passing Pointers to Functions

Passing by value

Passing pointer values

Passing by reference

Constant const Irritation

Making Use of a Block of Memory Called the Heap

Limited scope

Examining the scope problem

Providing a solution using the heap

Chapter 9: Taking a Second Look at C++ Pointers

Defining 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

Justifying pointer-based string manipulation

Applying operators to pointer types other than char

Contrasting a pointer with an array

When Is a Pointer Not?

Declaring and Using Arrays of Pointers

Utilizing arrays of character strings

Accessing the arguments to main()

Chapter 10: The C++ Preprocessor

What Is a Preprocessor?

Including Files

#Defining Things

Okay, how about not #defining things?

Enumerating other options

Including Things #if I Say So

Intrinsically Defined Objects

Typedef

Part III: Introduction to Classes

Chapter 11: Examining Object-Oriented Programming

Abstracting Microwave Ovens

Preparing functional nachos

Preparing object-oriented nachos

Classifying Microwave Ovens

Why Classify?

Chapter 12: Adding Class to C++

Introducing the Class

The Format of 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

Chapter 13: Point and Stare 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

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

Chapter 14: Protecting Members: Do Not Disturb

Protecting Members

Why you need protected members

Discovering how protected members work

Making an Argument for Using Protected Members

Protecting the internal state of the class

Using a class with a limited interface

Giving Non-member Functions Access to Protected Members

Chapter 15: “Why Do You Build Me Up, Just toTear 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

Chapter 16: Making Constructive Arguments

Outfitting Constructors with Arguments

Using a constructor

Placing Too Many Demands on the Carpenter: Overloading the Constructor

Defaulting Default Constructors

Constructing Class Members

Constructing a complex data member

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

Chapter 17: The Copy/Move Constructor

Copying an Object

Why you need the copy constructor

Using the copy constructor

The Automatic Copy Constructor

Creating Shallow Copies versus Deep Copies

It’s a Long Way to Temporaries

Avoiding temporaries, permanently

The move constructor

Chapter 18: Static Members: Can Fabric Softener Help?

Defining a Static Member

Why you need static members

Using static members

Referencing static data members

Uses for static data members

Declaring Static Member Functions

What Is this About Anyway?

Part IV: Inheritance

Chapter 19: Inheriting a Class

Do I Need My Inheritance?

How Does a Class Inherit?

Using a subclass

Constructing a subclass

Destructing a subclass

Inheriting constructors

Having a HAS_A Relationship

Chapter 20: Examining Virtual Member Functions: Are They for Real?

Why You Need Polymorphism

How Polymorphism Works

When Is a Virtual Function Not?

Considering Virtual Considerations

Chapter 21: Factoring Classes

Factoring

Implementing Abstract Classes

Describing the abstract class concept

Making an honest class out of an abstract class

Passing abstract classes

Part V: Security

Chapter 22: A New Assignment Operator, Should You Decide to Accept It

Comparing Operators with Functions

Inserting a New Operator

Creating Shallow Copies Is a Deep Problem

Overloading the Assignment Operator

Overloading the Subscript Operator

The Move Constructor and Move Operator

Chapter 23: Using Stream I/O

How Stream I/O Works

Default stream objects

Stream Input/Output

Open modes

Hey, file, what state are you in?

Can you show me an example?

Other Methods of the Stream Classes

Reading and writing streams directly

Controlling format

What's up with endl?

Positioning the pointer within a file

Using the stringstream Subclasses

Manipulating Manipulators

Chapter 24: Handling Errors — Exceptions

Justifying a New Error Mechanism?

Examining the Exception Mechanism

What Kinds of Things Can I Throw?

Just Passing Through

Chapter 25: Inheriting Multiple Inheritance

Describing the Multiple Inheritance Mechanism

Straightening Out Inheritance Ambiguities

Adding Virtual Inheritance

Constructing the Objects of Multiple Inheritance

Voicing a Contrary Opinion

Chapter 26: Tempting C++ Templates

Generalizing a Function into a Template

Class Templates

Tips for Using Templates

External Template Instantiations

Implementing an Initializer List

Chapter 27: Standardizing on the Standard Template Library

The string Container

Iterating through Lists

Making your way through a list

Operations on an entire list

Can you show me an example?

Chapter 28: Writing Hacker-Proof Code

Understanding the Hacker's Motives

Understanding Code Injection

Examining an example SQL injection

Avoiding code injection

Overflowing Buffers for Fun and Profit

Can I see an example?

How does a call stack up?

Hacking BufferOverflow

Avoiding buffer overflow — first attempt

Avoiding buffer overflow — second attempt

Another argument for the string class

Why not always use string functions?

Part VI: The Part of Tens

Chapter 29: Ten Ways to Avoid Adding Bugs to Your Program

Enable All Warnings and Error Messages

Adopt a Clear and Consistent Coding Style

Limit the Visibility

Comment Your Code While You Write It

Single-Step Every Path at Least Once

Avoid Overloading Operators

Manage the Heap Systematically

Use Exceptions to Handle Errors

Declare Destructors Virtual

Avoid Multiple Inheritance

Chapter 30: Ten Ways to Protect Your Programs from Hackers

Don't Make Assumptions about User Input

Handle Failures Gracefully

Maintain a Program Log

Follow a Good Development Process

Implement Good Version Control

Authenticate Users Securely

Manage Remote Sessions

Obfuscate Your Code

Sign Your Code With a Digital Certificate

Use Secure Encryption Wherever Necessary

About the Author

Cheat Sheet

People also search for (Ebook) C++ for Dummies 7th Edition:

c++ for dummies latest edition
    
c++ for dummies 7th edition
    
c++ for dummies pdf download
    
c++ for dummies free pdf
    
c++ for dummies pdf

Tags: Stephen Randy Davis, , C++, Dummies