Log In
Or create an account -> 
Imperial Library
  • Home
  • About
  • News
  • Upload
  • Forum
  • Help
  • Login/SignUp

Index
Cover Title Page Copyright 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 Touring the Essential Code::Blocks Features Using Other IDEs
Chapter 2: Configuring Your Mobile System
Obtaining CppDroid Considering Other Alternatives Touring the Essential CppDroid Features Obtaining CppDroid Help
Chapter 3: Creating Your First C++ Application
Code::Blocks Creating a Project Typing the Code Starting with Main Showing Information Let Your Application Run Away
Chapter 4: Storing Data in C++
Putting Your Data Places: Variables Manipulating Integer Variables Characters 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++ Including Evaluations in C++ Conditional Statements Repeating Actions with Statements That Loop Looping for Looping while Doing while Breaking and continuing Nesting loops
Chapter 6: Dividing Your Work with Functions
Dividing Your Work Calling a Function Writing Your Own Functions Improving On the Basic Function Calling All String Functions Understanding main()
Chapter 7: Splitting Up Source Code Files
Creating Multiple Source Files Sharing with Header Files 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 Heaping and Stacking the Variables Creating New Raw Pointers Freeing Raw Pointers Working with Smart Pointers 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 Working with a Class Starting and Ending with Constructors and Destructors Building Hierarchies of Classes Creating and Using Object Aliases
Chapter 2: Using Advanced C++ Features
Filling Your Code with Comments Converting Types Reading from the Console Understanding Preprocessor Directives Using Constants Using Switch Statements Supercharging enums with Classes Working with Random Numbers Storing Data in Arrays
Chapter 3: Planning and Building Objects
Recognizing Objects Encapsulating Objects Building Hierarchies
Chapter 4: Building with Design Patterns
Delving Into Pattern History Introducing a Simple Pattern: the Singleton Watching an Instance with an Observer Mediating with a Pattern
Book 3: Understanding Functional Programming
Chapter 1: Considering Functional Programming
Understanding How Functional Programming Differs Defining an Impure Language Seeing Data as Immutable Considering the Effects of State Eliminating Side Effects Understanding the Role of auto Passing Functions to Functions Using Lambda Expressions for Implementation
Chapter 2: Working with Lambda Expressions
Creating More Readable and Concise C++ Code Defining the Essential Lambda Expression Developing with Lambda Expressions
Chapter 3: Advanced Lambda Expressions
Considering the C++ 20 Lambda Extensions Working in Unevaluated Contexts Using Assignable Stateless Lambda Expressions Dealing with Pack Expansions
Book 4: Fixing Problems
Chapter 1: Dealing with Bugs
It's Not a Bug. It’s a Feature! Make Your Application Features Look Like Features Anticipating (Almost) Everything Avoiding Mistakes, Plain and Simple
Chapter 2: Debugging an Application
Programming with Debuggers Debugging with Different Tools Debugging a Code::Blocks Application with Command-Line Arguments
Chapter 3: Stopping and Inspecting Your Code
Setting and Disabling Breakpoints Watching, Inspecting, and Changing Variables
Chapter 4: Traveling About the Stack
Stacking Your Data Debugging with Advanced Features
Book 5: Advanced Programming
Chapter 1: Working with Arrays, Pointers, and References
Building Up Arrays Pointing with Pointers Referring to References
Chapter 2: Creating Data Structures
Working with Data Structuring Your Data Naming Your Space
Chapter 3: Constructors, Destructors, and Exceptions
Constructing and Destructing Objects Programming the Exceptions to the Rule
Chapter 4: Advanced Class Usage
Inherently Inheriting Correctly Using Classes and Types within Classes
Chapter 5: Creating Classes with Templates
Templatizing a Class Going Beyond the Basics Parameterizing a Template Typedefing a Template Deriving Templates Templatizing a Function
Chapter 6: Programming with the Standard Library
Architecting the Standard Library Containing Your Classes The Great Container Showdown Copying Containers Creating and Using Dynamic Arrays Working with Unordered Data Working with Ranges
Book 6: Reading and Writing Files
Chapter 1: Filing Information with the Streams Library
Seeing a Need for Streams Programming with the Streams Library Handling Errors When Opening a File Flagging the ios Flags
Chapter 2: Writing with Output Streams
Inserting with the << Operator Formatting Your Output
Chapter 3: Reading with Input Streams
Extracting with Operators Encountering the End of File Reading Various Types
Chapter 4: Building Directories and Contents
Manipulating Directories Getting the Contents of a Directory Copying Files Moving and Renaming Files and Directories
Chapter 5: Streaming Your Own Classes
Streaming a Class for Text Formatting Manipulating a Stream
Book 7: Advanced Standard Library Usage
Chapter 1: Exploring the Standard Library Further
Considering the Standard Library Categories Parsing Strings Using a Hash Obtaining Information Using a Random Access Iterator Locating Values Using the Find Algorithm Using the Random Number Generator Working with Temporary Buffers
Chapter 2: Working with User-Defined Literals (UDLs)
Understanding the Need for UDLs Working with the UDLs in the Standard Library Creating Your Own UDLs
Chapter 3: Building Original Templates
Deciding When to Create a Template Defining the Elements of a Good Template Creating a Basic Math Template Building a Structure Template Developing a Class Template Considering Template Specialization Creating a Template Library Using Your Template Library
Chapter 4: Investigating Boost
Considering the Standard Library Alternative Understanding Boost Obtaining and Installing Boost for Code::Blocks Creating the Boost Tools Using Boost.Build Using Inspect Understanding BoostBook Using QuickBook Using bcp Using Wave Building Your First Boost Application Using Date Time
Chapter 5: Boosting up a Step
Parsing Strings Using RegEx Breaking Strings into Tokens Using Tokenizer Performing Numeric Conversion Creating Improved Loops Using Foreach Accessing the Operating System Using Filesystem
Index About the Authors Connect with Dummies End User License Agreement
  • ← Prev
  • Back
  • Next →
  • ← Prev
  • Back
  • Next →

Chief Librarian: Las Zenow <zenow@riseup.net>
Fork the source code from gitlab.

This is a mirror of the Tor onion service:
http://kx5thpx2olielkihfyo4jgjqfb7zx7wxr3sd4xzt26ochei4m6f7tayd.onion