C++ in 24 Hours, Sams Teach Yourself

Series
Sams
Author
Rogers Cadenhead / Jesse Liberty  
Publisher
Sams Publishing
Cover
Softcover
Edition
6
Language
English
Total pages
480
Pub.-date
August 2016
ISBN13
9780672337468
ISBN
0672337460
Related Titles


Product detail

Product Price CHF Available  
9780672337468
C++ in 24 Hours, Sams Teach Yourself
39.30 approx. 7-9 days

Description

A hands-on guide to the C++ programming language, students are provided with short, practical examples of that illustrate key concepts, syntax, and techniques. Beginners with no previous programming experience learn about such fundamentals as managing I/O, loops and arrays, object-oriented programming, templates, and creating C++ applications - all in a cross-platform, standards-based manner.

Features

  • Unbeatable formula for learning C++ from scratch: Easy-to-understand chapters, well-crafted examples, and step-by-step instructions on downloading and installing a free C++ compiler
  • Co-author Rogers Cadenhead has a proven track record for teaching beginning programmers in an approachable yet highly engaging manner
  • The sixth edition of this international best seller includes new and updated material to take into account the new C++11 and C++14 standards

New to this Edition

The sixth edition of Sams Teach Yourself C++ in 24 Hours includes updated material to cover C++11 and C++14

Co-author Rogers Cadenhead brings his unique and popular teaching style to the material, freshening up the examples, de-densifying the material to make it more approachable and understandable for beginning programmers, and making full use of some of the more popular teaching elements found in other successful Teach Yourself books.

 

Table of Contents

 Introduction   1
PART I:  BEGINNING C++
Hour 1:  Writing Your First Program   5

Using C++   5
Compiling and Linking the Source Code   6
Creating Your First Program   7
Hour 2:  Organizing the Parts of a Program   13
Reasons to Use C++   13
The Parts of a Program   17
Comments   19
Functions   20
Hour 3:  Creating Variables and Constants   27
What Is a Variable?   27
Defining a Variable   32
Assigning Values to Variables   33
Using Type Definitions   34
Constants   36
Auto-Typed Variables   38
Hour 4:  Using Expressions, Statements, and Operators   43
Statements   43
Expressions   44
Operators   45
If-Else Conditional Statements   52
Logical Operators   56
Tricky Expression Values   58
Hour 5:  Calling Functions   61
What Is a Function?   61
Declaring and Defining Functions   61
Using Variables with Functions   64
Function Parameters   67
Returning Values from Functions   68
Default Function Parameters   70
Overloading Functions   72
Auto-Typed Return Values   73
Hour 6:  Controlling the Flow of a Program   79
Looping   79
while Loops   79
do-while Loops   83
for Loops   84
switch Statements   89
Hour 7:  Storing Information in Arrays and Strings   95
What Is an Array?   95
Writing Past the End of Arrays   97
Initializing Arrays   98
Multidimensional Arrays   99
Character Arrays   102
Copying Strings   104
Reading Arrays with Foreach Loops   105

PART II:  CLASSES
Hour 8:  Creating Basic Classes   109

What Is a Type?   109
Creating New Types   110
Classes and Members   110
Accessing Class Members   112
Private Versus Public Access   112
Implementing Member Functions   114
Creating and Deleting Objects   116
Hour 9:  Moving into Advanced Classes   123
const Member Functions   123
Interface Versus Implementation   124
Organizing Class Declarations and Function Definitions   124
Inline Implementation   124
Classes with Other Classes as Member Data   127

PART III:  MEMORY MANAGEMENT
Hour 10:  Creating Pointers   135

Understanding Pointers and Their Usage   135
The Stack and the Heap   145
Null Pointer Constant   150
Hour 11:  Developing Advanced Pointers   155
Creating Objects on the Heap   155
Deleting Objects   155
Accessing Data Members Using Pointers   157
Member Data on the Heap   158
The this Pointer   160
Stray or Dangling Pointers   161
const Pointers   162
const Pointers and const Member Functions   163
Hour 12:  Creating References   167
What is a Reference?   167
Creating a Reference   167
Using the Address of Operator on References   169
What Can Be Referenced?   171
Null Pointers and Null References   172
Passing Function Arguments by Reference   172
Understanding Function Headers and Prototypes   177
Returning Multiple Values   177
Hour 13:  Developing Advanced References and Pointers   183
Passing by Reference for Efficiency   183
Passing a const Pointer   186
References as an Alternative to Pointers   189
When to Use References and When to Use Pointers   191
References to Objects Not in Scope   191
Returning a Reference to an Object on the Heap   192
Pointer, Pointer, Who Has the Pointer?   195

PART IV:  ADVANCED C++
Hour 14:  Calling Advanced Functions   199

Overloaded Member Functions   199
Using Default Values   201
Initializing Objects   203
The Copy Constructor   204
Compile-Time Constant Expressions   208
Hour 15:  Using Operator Overloading   213
Operator Overloading   213
Conversion Operators   224

PART V:  INHERITANCE AND POLYMORPHISM
Hour 16:  Extending Classes with Inheritance   231

What Is Inheritance?   231
Private Versus Protected   234
Constructors and Destructors   236
Passing Arguments to Base Constructors   239
Overriding Functions   244
Hour 17:  Using Polymorphism and Derived Classes   251
Polymorphism Implemented with Virtual Member Functions   251
How Virtual Member Functions Work   256
Hour 18:  Making Use of Advanced Polymorphism   267
Problems with Single Inheritance   267
Abstract Data Types   271

PART VI:  SPECIAL TOPICS
Hour 19:  Storing Information in Linked Lists   287

Linked Lists and Other Structures   287
Linked List Case Study   289
Linked Lists as Objects   298
Hour 20:  Using Special Classes, Functions, and Pointers   301
Static Member Data   301
Static Member Functions   303
Containment of Classes   305
Friend Classes and Functions   312
Hour 21:  Using New Features of C++14   331
The Newest Version of C++   331
Using auto in Function Return Types   332
Improved Numeric Literals   334
The constexpr Keyword   335
Lambda Expressions   338
Hour 22:  Employing Object-Oriented Analysis and Design   343
The Development Cycle   343
Simulating an Alarm System   344
PostMaster:  A Case Study   350
Hour 23:  Creating Templates   373
What Are Templates?   373
Instances of the Template   374
Template Definition   374
Using Template Items   381
Hour 24:  Dealing with Exceptions and Error Handling   391
Bugs, Errors, Mistakes, and Code Rot   391
Handling the Unexpected   392
Exceptions   393
Using try and catch Blocks   397
Writing Professional-Quality Code   403

PART VII:  APPENDIXES
Appendix A:  Binary and Hexadecimal   411

Other Bases   412
Around the Bases   412
Hexadecimal   416
Appendix B:  Glossary   419
Appendix C:  This Book’s Website   427
Appendix D:  Using the MinGW C++ Compiler on Windows   429

Downloading MinGW-w64   429
Setting the Path Environment Variable   431
Testing Your Installation   433
Index   439

Author

Rogers Cadenhead is a writer, computer programmer, and web developer who has written more than 25 books on Internet-related topics, including Sams Teach Yourself Java in 21 Days and Absolute Beginner’s Guide to Minecraft Mods Programming. He publishes the Drudge Retort and other websites that receive more than 22 million visits a year. This book’s official website is at http://cplusplus.cadenhead.org.

Jesse Liberty is the author of numerous books on software development, including best-selling titles on C++ and .NET. He is the president of Liberty Associates, Inc. (www.libertyassociates.com), where he provides custom programming, consulting, and training.