book

Beginning Programming with C++ For Dummies®

Name: Beginning Programming with C++ For Dummies®
Author: Nat Coalson
ISBN: 9780470617977

by Nat Coalson

August 2010

Beginner

456 pages

8h 7m

English

For Dummies

Read now

Unlock full access

Copyright
About the Author
Author's Acknowledgments
Publisher's Acknowledgments
Introduction
About Beginning Programming with C++ For DummiesFoolish AssumptionsConventions Used in This BookWhat You Don't Have to ReadHow This Book Is OrganizedPart I: Let's Get StartedPart II: Writing a Program: Decisions, DecisionsPart III: Becoming a Functional ProgrammerPart IV: Data StructuresPart V: Object-Oriented ProgrammingPart VI: Advanced StrokesPart VII: The Part of TensThe CD-ROM AppendixIcons Used in This BookWhere to Go from Here
I. Let's Get Started
1. What Is a Program?
1.1. How Does My Son Differ from a Computer?1.2. Programming a "Human Computer"1.2.1. The algorithm1.2.2. The Tire Changing Language1.2.3. The program1.2.4. Computer processors1.3. Computer Languages1.3.1. High level languages1.3.2. The C++ language
2. Installing Code::Blocks
2.1. Reviewing the Compilation Process2.2. Installing Code::Blocks2.3. Testing the Code::Blocks Installation2.3.1. Creating the project2.3.2. Testing your default project
3. Writing Your First Program
3.1. Creating a New Project3.2. Entering Your Program3.3. Building the Program3.4. Finding What Could Go Wrong3.4.1. Misspelled commands3.4.2. Missing semicolon3.5. Using the Enclosed CD-ROM3.6. Running the Program3.7. How the Program Works3.7.1. The template3.7.1.1. Comments3.7.1.2. Include files3.7.1.3. main3.7.2. The Conversion program
II. Writing a Program: Decisions, Decisions

4. Integer Expressions
4.1. Declaring Variables4.1.1. Variable names4.1.2. Assigning a value to a variable4.1.3. Initializing a variable at declaration4.2. Integer Constants4.3. Expressions4.3.1. Binary operators4.3.2. Decomposing compound expressions4.4. Unary Operators4.5. The Special Assignment Operators
5. Character Expressions
5.1. Defining Character Variables5.1.1. Encoding characters5.1.2. Example of character encoding5.2. Encoding Strings of Characters5.3. Special Character Constants
6. if I Could Make My Own Decisions
6.1. The if Statement6.1.1. Comparison operators6.1.2. Say "No" to "No braces"6.2. What else Is There?6.3. Nesting if Statements6.4. Compound Conditional Expressions
7. Switching Paths
7.1. Controlling Flow with the switch Statement7.2. Control Fell Through: Did I break It?7.3. Implementing an Example Calculator with the switch Statement
8. Debugging Your Programs, Part I
8.1. Identifying Types of Errors8.2. Avoiding Introducing Errors8.2.1. Coding with style8.2.2. Establishing variable naming conventions8.3. Finding the First Error with a Little Help8.4. Finding the Run-Time Error8.4.1. Formulating test data8.4.2. Executing the test cases8.4.3. Seeing what's going on in your program
III. Becoming a Functional Programmer
9. while Running in Circles
9.1. Creating a while Loop9.2. Breaking out of the Middle of a Loop9.3. Nested Loops
10. Looping for the Fun of It
10.1. The for Parts of Every Loop10.2. Looking at an Example10.3. Getting More Done with the Comma Operator
11. Functions, I Declare!
11.1. Breaking Your Problem Down into Functions11.2. Understanding How Functions Are Useful11.3. Writing and Using a Function11.3.1. Returning things11.3.2. Reviewing an example11.4. Passing Arguments to Functions11.4.1. Function with arguments11.4.2. Functions with multiple arguments11.4.3. Exposing main()11.5. Defining Function Prototype Declarations
12. Dividing Programs into Modules
12.1. Breaking Programs Apart12.2. Breaking Up Isn't That Hard to Do12.2.1. Creating Factorial.cpp12.2.2. Creating an #include file12.2.3. Including #include files12.2.4. Creating main.cpp12.2.5. Building the result12.3. Using the Standard C++ Library12.4. Variable Scope
13. Debugging Your Programs, Part 2
13.1. Debugging a Dys-Functional Program13.1.1. Performing unit level testing13.1.2. Outfitting a function for testing13.1.3. Returning to unit test
IV. Data Structures
14. Other Numerical Variable Types
14.1. The Limitations of Integers in C++14.1.1. Integer round-off14.1.2. Limited range14.2. A Type That "doubles" as a Real Number14.2.1. Solving the truncation problem14.2.2. When an integer is not an integer14.2.3. Discovering the limits of double14.2.3.1. Counting14.2.3.2. Calculation speed14.2.3.3. Consume more memory14.2.3.4. Loss of accuracy14.2.3.5. Not so limited range14.3. Variable Size — the "long" and "short" of It14.3.1. How far do numbers range?14.4. Types of Constants14.5. Passing Different Types to Functions14.5.1. Overloading function names14.5.2. Mixed mode overloading
15. Arrays
15.1. What Is an Array?15.2. Declaring an Array15.3. Indexing into an Array15.4. Looking at an Example15.5. Initializing an Array
16. Arrays with Character
16.1. The ASCII-Zero Character Array16.2. Declaring and Initializing an ASCIIZ Array16.3. Looking at an Example16.4. Looking at a More Detailed Example16.4.1. Foiling hackers16.4.2. Do I Really Have to Do All That Work?
17. Pointing the Way to C++ Pointers
17.1. What's a Pointer?17.2. Declaring a Pointer17.3. Passing Arguments to a Function17.3.1. Passing arguments by value17.3.2. Passing arguments by reference17.3.3. Putting it together17.4. Playing with Heaps of Memory17.4.1. Do you really need a new keyword?17.4.2. Don't forget to clean up after yourself17.4.3. Looking at an example
18. Taking a Second Look at C++ Pointers
18.1. Pointers and Arrays18.1.1. Operations on pointers18.1.2. Pointer addition versus indexing into an array18.1.3. Using the pointer increment operator18.1.4. Why bother with array pointers?18.2. Operations on Different Pointer Types18.3. Constant Nags18.4. Differences Between Pointers and Arrays18.5. My main() Arguments18.5.1. Arrays of pointers18.5.2. Arrays of arguments18.5.2.1. Passing arguments to your program through the command line18.5.2.2. Passing arguments to your program from the Code::Blocks environment18.5.2.3. Passing arguments to your program through Windows
19. Programming with Class
19.1. Grouping Data19.2. The Class19.3. The Object19.4. Arrays of Objects19.5. Looking at an Example
20. Debugging Your Programs, Part 3
20.1. A New Approach to Debugging20.1.1. The solution20.2. Entomology for Dummies20.2.1. Starting the debugger20.2.2. Navigating through a program with the debugger20.2.3. Fixing the (first) bug20.2.4. Finding and fixing the second bug
V. Object-Oriented Programming
21. What Is Object-Oriented Programming?
21.1. Abstraction and Microwave Ovens21.1.1. Functional nachos21.1.2. Object-oriented nachos21.2. Classification and Microwave Ovens21.3. Why Build Objects This Way?21.4. Self-Contained Classes
22. Structured Play: Making Classes Do Things
22.1. Activating Our Objects22.2. Creating a Member Function22.2.1. Defining a member function22.2.2. Naming class members22.2.3. Calling a member function22.2.4. Accessing other members from within a member function22.3. Keeping a Member Function after Class22.4. Overloading Member Functions
23. Pointers to Objects
23.1. Pointers to Objects23.1.1. Arrow syntax23.1.2. Calling all member functions23.2. Passing Objects to Functions23.2.1. Calling a function with an object value23.2.2. Calling a function with an object pointer23.2.3. Looking at an example23.3. Allocating Objects off the Heap
24. Do Not Disturb: Protected Members
24.1. Protecting Members24.1.1. Why you need protected members24.1.2. Making members protected24.1.3. So what?24.2. Who Needs Friends Anyway?
25. Getting Objects Off to a Good Start
25.1. The Constructor25.1.1. Limitations on constructors25.1.2. Can I see an example?25.1.3. Constructing data members25.2. Destructors25.2.1. Looking at an example25.2.2. Destructing data members
26. Making Constructive Arguments
26.1. Constructors with Arguments26.1.1. Looking at an example26.2. Overloading the Constructor26.3. The Default default Constructor26.4. Constructing Data Members26.4.1. Initializing data members with the default constructor26.4.2. Initializing data members with a different constructor26.4.3. Looking at an example26.4.4. New with C++ 2009
27. Coping with the Copy Constructor
27.1. Copying an Object27.1.1. The default copy constructor27.1.2. Looking at an example27.2. Creating a Copy Constructor27.3. Avoiding Copies
VI. Advanced Strokes
28. Inheriting a Class
28.1. Advantages of Inheritance28.1.1. Learning the lingo28.2. Implementing Inheritance in C++28.2.1. Looking at an example28.3. Having a HAS_A Relationship
29. Are Virtual Functions for Real?
29.1. Overriding Member Functions29.1.1. Early binding29.1.2. Ambiguous case29.1.3. Enter late binding29.2. When Is Virtual Not?29.3. Virtual Considerations
30. Overloading Assignment Operators
30.1. Overloading an Operator30.2. Overloading the Assignment Operator Is Critical30.3. Looking at an Example30.4. Writing Your Own (or Not)
31. Performing Streaming I/O
31.1. How Stream I/O Works31.2. Stream Input/Output31.2.1. Creating an input object31.2.2. Creating an output object31.2.3. Open modes31.2.4. What is binary mode?31.2.5. Hey, file, what state are you in?31.3. Other Member Functions of the fstream Classes31.3.1. Reading and writing streams directly31.3.2. Controlling format31.3.3. What's up with endl?31.4. Manipulating Manipulators31.5. Using the stringstream Classes
32. I Take Exception!
32.1. The Exception Mechanism32.1.1. Examining the exception mechanism in detail32.1.2. Special considerations for throwing32.2. Creating a Custom Exception Class32.2.1. Restrictions on exception classes
VII. The Part of Tens
33. Ten Ways to Avoid Bugs
33.1. Enable All Warnings and Error Messages33.2. Adopt a Clear and Consistent Coding Style33.3. Comment the Code While You Write It33.4. Single-Step Every Path in the Debugger at Least Once33.5. Limit the Visibility33.6. Keep Track of Heap Memory33.7. Zero Out Pointers after Deleting What They Point To33.8. Use Exceptions to Handle Errors33.9. Declare Destructors Virtual33.10. Provide a Copy Constructor and Overloaded Assignment Operator
34. Ten Features Not Covered in This Book
34.1. The goto Command34.2. The Ternary Operator34.3. Binary Logic34.4. Enumerated Types34.5. Namespaces34.6. Pure Virtual Functions34.7. The string Class34.8. Multiple Inheritance34.9. Templates and the Standard Template Library34.10. The 2009 C++ Standard
A. About the CD
A.1. System RequirementsA.2. Using the CDA.3. What You'll Find on the CDA.3.1. CPP programsA.3.2. Code::Blocks development environmentA.4. TroubleshootingA.5. Customer Care

Content preview from Beginning Programming with C++ For Dummies®

Part III. Becoming a Functional Programmer

In this part ...

Now that you've mastered the basics of simple expressions, it's time for you to learn about loops, how to get into them, and, even more importantly, how to get out of them. You'll also see how to break a large program into smaller components that are easier to program. In the last chapter of this part, you'll see some more techniques for debugging your programs.

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

Read now

Unlock full access

More than 5,000 organizations count on O’Reilly

O’Reilly covers everything we've got, with content to help us build a world-class technology community, upgrade the capabilities and competencies of our teams, and improve overall team performance as well as their engagement.

Julian F.

Head of Cybersecurity

I wanted to learn C and C++, but it didn't click for me until I picked up an O'Reilly book. When I went on the O’Reilly platform, I was astonished to find all the books there, plus live events and sandboxes so you could play around with the technology.

Addison B.

Field Engineer

I’ve been on the O’Reilly platform for more than eight years. I use a couple of learning platforms, but I'm on O'Reilly more than anybody else. When you're there, you start learning. I'm never disappointed.

Amir M.

Data Platform Tech Lead

I'm always learning. So when I got on to O'Reilly, I was like a kid in a candy store. There are playlists. There are answers. There's on-demand training. It's worth its weight in gold, in terms of what it allows me to do.

Mark W.

Embedded Software Engineer

Publisher Resources

ISBN: 9780470617977Purchase book

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills

Beginning Programming with C++ For Dummies®

by Nat Coalson

Part III. Becoming a Functional Programmer

In this part ...

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.