C++ crash course : a fast-paced introduction

A fast-paced, thorough introduction to modern C++ written for experienced programmers. After reading C++ Crash Course , you'll be proficient in the core language concepts, the C++ Standard Library, and the Boost Libraries. C++ is one of the most widely used languages for real-world software. In the hands of a knowledgeable programmer, C++ can produce small, efficient, and readable code that any programmer would be proud of. Designed for intermediate to advanced programmers, C++ Crash Course cuts through the weeds to get you straight to the core of C++17, the most modern revision of the ISO standard. Part 1 covers the core of the C++ language, where you'll learn about everything from types and functions, to the object life cycle and expressions. Part 2 introduces you to the C++ Standard Library and Boost Libraries, where you'll learn about all of the high-quality, fully-featured facilities available to you. You'll cover special utility classes, data structures, and algorithms, and learn how to manipulate file systems and build high-performance programs that communicate over networks. You'll learn all the major features of modern C++, including: &; Fundamental types, reference types, and user-defined types &; The object lifecycle including storage duration, memory management, exceptions, call stacks, and the RAII paradigm &; Compile-time polymorphism with templates and run-time polymorphism with virtual classes &; Advanced expressions, statements, and functions &; Smart pointers, data structures, dates and times, numerics, and probability/statistics facilities &; Containers, iterators, strings, and algorithms &; Streams and files, concurrency, networking, and application development With well over 500 code samples and nearly 100 exercises, C++ Crash Course is sure to help you build a strong C++ foundation. Brief Contents Contents in Detail Foreword Acknowledgments Introduction About This Book Who Should Read This Book? What’s in This Book? Part I: The C++ Core Language Part II: C++ Libraries and Frameworks An Overture to C Programmers Upgrading to Super C Function Overloading References auto Initialization Namespaces and Implicit typedef of struct, union, and enum Intermingling C and C++ Object Files C++ Themes Expressing Ideas Concisely and Reusing Code The C++ Standard Library Lambdas Generic Programming with Templates Class Invariants and Resource Management Move Semantics Relax and Enjoy Your Shoes Part I: The C++ Core Language Chapter 1: Up and Running The Structure of a Basic C++ Program Creating Your First C++ Source File Main: A C++ Program’s Starting Point Libraries: Pulling in External Code The Compiler Tool Chain Setting Up Your Development Environment Windows 10 and Later: Visual Studio macOS: Xcode Linux and GCC Text Editors Bootstrapping C++ The C++ Type System Declaring Variables Initializing a Variable’s State Conditional Statements Functions printf Format Specifiers Revisiting step_function Comments Debugging Visual Studio Xcode GCC and Clang Debugging with GDB and LLDB Summary Chapter 2: Types Fundamental Types Integer Types Floating-Point Types Character Types Boolean Types The std::byte Type The size_t Type void Arrays Array Initialization Accessing Array Elements A Nickel Tour of for Loops C-Style Strings User-Defined Types Enumeration Types Plain-Old-Data Classes Unions Fully Featured C++ Classes Methods Access Controls Constructors Initialization The Destructor Summary Chapter 3: Reference Types Pointers Addressing Variables Dereferencing Pointers The Member-of-Pointer Operator Pointers and Arrays Pointers Are Dangerous void Pointers and std::byte Pointers nullptr and Boolean Expressions References Usage of Pointers and References Forward-Linked Lists: The Canonical Pointer-Based Data Structure Employing References this Pointers const Correctness const Member Variables Member Initializer Lists auto Type Deduction Initialization with auto auto and Reference Types auto and Code Refactorings Summary Chapter 4: The Object Life Cycle An Object’s Storage Duration Allocation, Deallocation, and Lifetime Memory Management Automatic Storage Duration Static Storage Duration Thread-Local Storage Duration Dynamic Storage Duration Tracing the Object Life Cycle Exceptions The throw Keyword Using try-catch Blocks stdlib Exception Classes Handling Exceptions User-Defined Exceptions The noexcept Keyword Call Stacks and Exceptions A SimpleString Class Appending and Printing Using SimpleString Composing a SimpleString Call Stack Unwinding Exceptions and Performance Alternatives to Exceptions Copy Semantics Copy Constructors Copy Assignment Default Copy Copy Guidelines Move Semantics Copying Can Be Wasteful Value Categories lvalue and rvalue References The std::move Function Move Construction Move Assignment The Final Product Compiler-Generated Methods Summary Chapter 5: Runtime Polymorphism Polymorphism A Motivating Example Adding New Loggers Interfaces Object Composition and Implementation Inheritance Defining Interfaces Base Class Inheritance Member Inheritance virtual Methods Pure-Virtual Classes and Virtual Destructors Implementing Interfaces Using Interfaces Updating the Bank Logger Constructor Injection Property Injection Choosing Constructor or Property Injection Summary Chapter 6: Compile-Time Polymorphism Templates Declaring Templates Template Class Definitions Template Function Definitions Instantiating Templates Named Conversion Functions const_cast static_cast reinterpret_cast narrow_cast mean: A Template Function Example Genericizing mean Template Type Deduction SimpleUniquePointer: A Template Class Example Type Checking in Templates Concepts Defining a Concept Type Traits Requirements Building Concepts from Requires Expressions Using Concepts Ad Hoc Requires Expressions static_assert: The Preconcepts Stopgap Non-Type Template Parameters Variadic Templates Advanced Template Topics Template Specialization Name Binding Type Function Template Metaprogramming Template Source Code Organization Polymorphism at Runtime vs. Compile Time Summary Chapter 7: Expressions Operators Logical Operators Arithmetic Operators Assignment Operators Increment and Decrement Operators Comparison Operators Member Access Operators Ternary Conditional Operator The Comma Operator Operator Overloading Overloading Operator new Operator Precedence and Associativity Evaluation Order User-Defined Literals Type Conversions Implicit Type Conversions Explicit Type Conversion C-Style Casts User-Defined Type Conversions Constant Expressions A Colorful Example The Case for constexpr Volatile Expressions Summary Chapter 8: Statements Expression Statements Compound Statements Declaration Statements Functions Namespaces Type Aliasing Structured Bindings Attributes Selection Statements if Statements switch Statements Iteration Statements while Loops do-while Loops for Loops Ranged-Based for Loops Jump Statements break Statements continue Statements goto Statements Summary Chapter 9: Functions Function Declarations Prefix Modifiers Suffix Modifiers auto Return Types auto and Function Templates Overload Resolution Variadic Functions Variadic Templates Programming with Parameter Packs Revisiting the sum Function Fold Expressions Function Pointers Declaring a Function Pointer Type Aliases and Function Pointers The Function-Call Operator A Counting Example Lambda Expressions Usage Lambda Parameters and Bodies Default Arguments Generic Lambdas Lambda Return Types Lambda Captures constexpr Lambda Expressions std::function Declaring a Function An Extended Example The main Function and the Command Line The Three main Overloads Exploring Program Parameters A More Involved Example Exit Status Summary Part II: C++ Libraries and Frameworks Chapter 10: Testing Unit Tests Integration Tests Acceptance Tests Performance Tests An Extended Example: Taking a Brake Implementing AutoBrake Test-Driven Development Adding a Service-Bus Interface Unit-Testing and Mocking Frameworks The Catch Unit-Testing Framework Google Test Boost Test Summary: Testing Frameworks Mocking Frameworks Google Mock HippoMocks A Note on Other Mocking Options: FakeIt and Trompeloeil Summary Chapter 11: Smart Pointers Smart Pointers Smart Pointer Ownership Scoped Pointers Constructing Bring in the Oath Breakers Implicit bool Conversion Based on Ownership RAII Wrapper Pointer Semantics Comparison with nullptr Swapping Resetting and Replacing a scoped_ptr Non-transferability boost::scoped_array A Partial List of Supported Operations Unique Pointers Constructing Supported Operations Transferable, Exclusive Ownership Unique Arrays Deleters Custom Deleters and System Programming A Partial List of Supported Operations Shared Pointers Constructing Specifying an Allocator Supported Operations Transferable, Non-Exclusive Ownership Shared Arrays Deleters A Partial List of Supported Operations Weak Pointers Constructing Obtaining Temporary Ownership Advanced Patterns Supported Operations Intrusive Pointers Summary of Smart Pointer Options Allocators Summary Chapter 12: Utilities Data Structures tribool optional pair tuple any variant Date and Time Boost DateTime Chrono Numerics Numeric Functions Complex Numbers Mathematical Constants Random Numbers Numeric Limits Boost Numeric Conversion Compile-Time Rational Arithmetic Summary Chapter 13: Containers Sequence Containers Arrays Vectors Niche Sequential Containers Associative Containers Sets Unordered Sets Maps Niche Associative Containers Graphs and Property Trees The Boost Graph Library Boost Property Trees Initializer Lists Summary Chapter 14: Iterators Iterator Categories Output Iterators Input Iterators Forward Iterators Bidirectional Iterators Random-Access Iterators Contiguous Iterators Mutable Iterators Auxiliary Iterator Functions std::advance std::next and std::prev std::distance std::iter_swap Additional Iterator Adapters Move Iterator Adapters Reverse Iterator Adapters Summary Chapter 15: Strings std::string Constructing String Storage and Small String Optimizations Element and Iterator Access String Comparisons Manipulating Elements Search Numeric Conversions String View Constructing Supported string_view Operations Ownership, Usage, and Efficiency Regular Expressions Patterns basic_regex Algorithms Boost String Algorithms Boost Range Predicates Classifiers Finders Modifying Algorithms Splitting and Joining Searching Boost Tokenizer Localizations Summary Chapter 16: Streams Streams Stream Classes Stream State Buffering and Flushing Manipulators User-Defined Types String Streams File Streams Stream Buffers Random Access Summary Chapter 17: Filesystems Filesystem Concepts std::filesystem::path Constructing Paths Decomposing Paths Modifying Paths Summary of Filesystem Path Methods Files and Directories Error Handling Path-Composing Functions Inspecting File Types Inspecting Files and Directories Manipulating Files and Directories Directory Iterators Constructing Directory Entries Recursive Directory Iteration fstream Interoperation Summary Chapter 18: Algorithms Algorithmic Complexity Execution Policies Non-Modifying Sequence Operations all_of any_of none_of for_each for_each_n find, find_if, and find_if_not find_end find_first adjacent_find count mismatch equal is_permutation search search_n Mutating Sequence Operations copy copy_n copy_backward move move_backward swap_ranges transform replace fill generate remove unique reverse sample shuffle Sorting and Related Operations sort stable_sort partial_sort is_sorted nth_element Binary Search lower_bound upper_bound equal_range binary_search Partitioning Algorithms is_partitioned partition partition_copy stable_partition Merging Algorithms merge Extreme-Value Algorithms min and max min_element and max_element clamp Numeric Operations Useful Operators iota accumulate reduce inner_product adjacent_difference partial_sum Other Algorithms Boost Algorithms Chapter 19: Concurrency and Parallelism Concurrent Programming Asynchronous Tasks Sharing and Coordinating Low-Level Concurrency Facilities Parallel Algorithms An Example: Parallel sort Parallel Algorithms Are Not Magic Summary Chapter 20: Network Programming with Boost Asio The Boost Asio Programming Model Network Programming with Asio The Internet Protocol Suite Hostname Resolution Connecting Buffers Reading and Writing Data with Buffers The Hypertext Transfer Protocol (HTTP) Implementing a Simple Boost Asio HTTP Client Asynchronous Reading and Writing Serving Multithreading Boost Asio Summary Chapter 21: Writing Applications Program Support Handling Program Termination and Cleanup Communicating with the Environment Managing Operating System Signals Boost ProgramOptions The Options Description Parsing Options Storing and Accessing Options Putting It All Together Special Topics in Compilation Revisiting the Preprocessor Compiler Optimization Linking with C Summary Index Blank Page Blank Page A fast-paced, thorough introduction to modern C++ written for experienced programmers. After reading C++ Crash Course, you'll be proficient in the core language concepts, the C++ Standard Library, and the Boost Libraries. C++ is one of the most widely used languages for real-world software. In the hands of a knowledgeable programmer, C++ can produce small, efficient, and readable code that any programmer would be proud of. Designed for intermediate to advanced programmers, C++ Crash Course cuts through the weeds to get you straight to the core of C++ 17, the most modern revision of the ISO standard. Part 1 covers the core of the C++ language, where you'll learn about everything from types and functions, to the object life cycle and expressions. Part 2 introduces you to the C++ Standard Library and Boost Libraries, where you'll learn about all of the high-quality, fully-featured facilities available to you. You'll cover special utility classes, data structures, and algorithms, and learn how to manipulate file systems and build high-performance programs that communicate over networks. You'll learn all the major features of modern C++, including: - Fundamental types, reference types, and user-defined types - The object lifecycle including storage duration, memory management, exceptions, call stacks, and the RAII paradigm - Compile-time polymorphism with templates and run-time polymorphism with virtual classes - Advanced expressions, statements, and functions - Smart pointers, data structures, dates and times, numerics, and probability/statistics facilities - Containers, iterators, strings, and algorithms - Streams and files, concurrency, networking, and application development With well over 500 code samples and nearly 100 exercises, C++ Crash Course is sure to help you build a strong C++ foundation. C++ is one of the most widely used languages for real-world software. In the hands of a knowledgeable programmer, C++ can produce small, efficient, and readable code that any programmer would be proud of. Designed for intermediate to advanced programmers, C++ Crash Course cuts through the weeds to get you straight to the core of C++17, the most modern revision of the ISO standard. Part 1 covers the core of the C++ language, where you'll learn about everything from types and functions, to the object life cycle and expressions. Part 2 introduces you to the C++ Standard Library and Boost Libraries, where you'll learn about all of the high-quality, fully-featured facilities available to you. You'll cover special utility classes, data structures, and algorithms, and learn how to manipulate file systems and build high-performance programs that communicate over networks. [Source : 4e de couv.]