ebook img

Beginning C++17 From Novice to Professional PDF

788 Pages·2018·9.65 MB·English
Save to my drive
Quick download
Download
Most books are stored in the elastic cloud where traffic is expensive. For this reason, we have a limit on daily download.

Preview Beginning C++17 From Novice to Professional

Beginning C++17 From Novice to Professional — Fifth Edition — Ivor Horton Peter Van Weert Beginning C++17 From Novice to Professional Fifth Edition Ivor Horton Peter Van Weert Beginning C++17: From Novice to Professional Ivor Horton Peter Van Weert Stratford-upon-Avon, Warwickshire, United Kingdom Kessel-Lo, Belgium ISBN-13 (pbk): 978-1-4842-3365-8 ISBN-13 (electronic): 978-1-4842-3366-5 https://doi.org/10.1007/978-1-4842-3366-5 Library of Congress Control Number: 2018936369 Copyright © 2018 by Ivor Horton and Peter Van Weert This work is subject to copyright. All rights are reserved by the Publisher, whether the whole or part of the material is concerned, specifically the rights of translation, reprinting, reuse of illustrations, recitation, broadcasting, reproduction on microfilms or in any other physical way, and transmission or information storage and retrieval, electronic adaptation, computer software, or by similar or dissimilar methodology now known or hereafter developed. Trademarked names, logos, and images may appear in this book. Rather than use a trademark symbol with every occurrence of a trademarked name, logo, or image we use the names, logos, and images only in an editorial fashion and to the benefit of the trademark owner, with no intention of infringement of the trademark. The use in this publication of trade names, trademarks, service marks, and similar terms, even if they are not identified as such, is not to be taken as an expression of opinion as to whether or not they are subject to proprietary rights. While the advice and information in this book are believed to be true and accurate at the date of publication, neither the authors nor the editors nor the publisher can accept any legal responsibility for any errors or omissions that may be made. The publisher makes no warranty, express or implied, with respect to the material contained herein. Managing Director, Apress Media LLC: Welmoed Spahr Acquisitions Editor: Steve Anglin Development Editor: Matthew Moodie Coordinating Editor: Mark Powers Cover designed by eStudioCalamar Cover image designed by Freepik (www.freepik.com) Distributed to the book trade worldwide by Springer Science+Business Media New York, 233 Spring Street, 6th Floor, New York, NY 10013. Phone 1-800-SPRINGER, fax (201) 348-4505, e-mail [email protected], or visit www.springeronline.com. Apress Media, LLC is a California LLC and the sole member (owner) is Springer Science + Business Media Finance Inc (SSBM Finance Inc). SSBM Finance Inc is a Delaware corporation. For information on translations, please e-mail [email protected]; for reprint, paperback, or audio rights, please email [email protected]. Apress titles may be purchased in bulk for academic, corporate, or promotional use. eBook versions and licenses are also available for most titles. For more information, reference our Print and eBook Bulk Sales web page at www.apress.com/bulk-sales. Any source code or other supplementary material referenced by the author in this book is available to readers on GitHub via the book’s product page, located at www.apress.com/9781484233658. For more detailed information, please visit www.apress.com/source-code. Printed on acid-free paper This is for Alexander and Henry who are both going to learn programming soon. If their amazing expertise with Minecraft is anything to go by, they will be brilliant at it. —Ivor Horton For my wonderful family. For all your love and support. For putting up with me never having the time to help out around the house or to play with the train set I got you for Christmas. —Peter Van Weert Contents About the Authors �������������������������������������������������������������������������������������������������xxiii About the Technical Reviewer �������������������������������������������������������������������������������xxv Introduction ���������������������������������������������������������������������������������������������������������xxvii ■ Chapter 1: Basic Ideas �������������������������������������������������������������������������������������������1 Modern C++ ���������������������������������������������������������������������������������������������������������������������1 Standard Libraries ������������������������������������������������������������������������������������������������������������2 C++ Program Concepts ����������������������������������������������������������������������������������������������������3 Source Files and Header Files ����������������������������������������������������������������������������������������������������������������3 Comments and Whitespace ��������������������������������������������������������������������������������������������������������������������4 Preprocessing Directives and Standard Library Headers �����������������������������������������������������������������������4 Functions ������������������������������������������������������������������������������������������������������������������������������������������������5 Statements ���������������������������������������������������������������������������������������������������������������������������������������������5 Data Input and Output�����������������������������������������������������������������������������������������������������������������������������6 return Statements�����������������������������������������������������������������������������������������������������������������������������������7 Namespaces �������������������������������������������������������������������������������������������������������������������������������������������7 Names and Keywords �����������������������������������������������������������������������������������������������������������������������������8 Classes and Objects ���������������������������������������������������������������������������������������������������������9 Templates �������������������������������������������������������������������������������������������������������������������������9 Code Appearance and Programming Style �����������������������������������������������������������������������9 Creating an Executable ��������������������������������������������������������������������������������������������������10 Procedural and Object-Oriented Programming ��������������������������������������������������������������12 v ■ Contents Representing Numbers ���������������������������������������������������������������������������������������������������13 Binary Numbers ������������������������������������������������������������������������������������������������������������������������������������13 Hexadecimal Numbers �������������������������������������������������������������������������������������������������������������������������14 Negative Binary Numbers ���������������������������������������������������������������������������������������������������������������������16 Octal Values ������������������������������������������������������������������������������������������������������������������������������������������17 Bi-Endian and Little-Endian Systems ���������������������������������������������������������������������������������������������������18 Floating-Point Numbers ������������������������������������������������������������������������������������������������������������������������19 Representing Characters ������������������������������������������������������������������������������������������������20 ASCII Codes ������������������������������������������������������������������������������������������������������������������������������������������21 UCS and Unicode ����������������������������������������������������������������������������������������������������������������������������������21 C++ Source Characters ��������������������������������������������������������������������������������������������������22 Escape Sequences �������������������������������������������������������������������������������������������������������������������������������22 Summary ������������������������������������������������������������������������������������������������������������������������24 ■ Chapter 2: Introducing Fundamental Types of Data ��������������������������������������������27 Variables, Data, and Data Types �������������������������������������������������������������������������������������27 Defining Integer Variables���������������������������������������������������������������������������������������������������������������������28 Zero Initialization ����������������������������������������������������������������������������������������������������������������������������������31 Defining Variables with Fixed Values ����������������������������������������������������������������������������������������������������32 Integer Literals ���������������������������������������������������������������������������������������������������������������32 Decimal Integer Literals������������������������������������������������������������������������������������������������������������������������32 Hexadecimal Literals ����������������������������������������������������������������������������������������������������������������������������33 Octal Literals �����������������������������������������������������������������������������������������������������������������������������������������34 Binary Literals���������������������������������������������������������������������������������������������������������������������������������������34 Calculations with Integers ����������������������������������������������������������������������������������������������35 Compound Arithmetic Expressions �������������������������������������������������������������������������������������������������������36 Assignment Operations ��������������������������������������������������������������������������������������������������37 The op= Assignment Operators ������������������������������������������������������������������������������������������������������������40 The sizeof Operator ��������������������������������������������������������������������������������������������������������42 vi ■ Contents Incrementing and Decrementing Integers ����������������������������������������������������������������������42 Postfix Increment and Decrement Operations ��������������������������������������������������������������������������������������43 Defining Floating-Point Variables �����������������������������������������������������������������������������������44 Floating-Point Literals ����������������������������������������������������������������������������������������������������45 Floating-Point Calculations ��������������������������������������������������������������������������������������������46 Pitfalls ���������������������������������������������������������������������������������������������������������������������������������������������������46 Invalid Floating-Point Results ���������������������������������������������������������������������������������������������������������������47 Mathematical Functions �����������������������������������������������������������������������������������������������������������������������48 Formatting Stream Output ����������������������������������������������������������������������������������������������51 Mixed Expressions and Type Conversion ������������������������������������������������������������������������53 Explicit Type Conversion �������������������������������������������������������������������������������������������������54 Old-Style Casts �������������������������������������������������������������������������������������������������������������������������������������56 Finding the Limits �����������������������������������������������������������������������������������������������������������57 Finding Other Properties of Fundamental Types �����������������������������������������������������������������������������������58 Working with Character Variables ����������������������������������������������������������������������������������59 Working with Unicode Characters ��������������������������������������������������������������������������������������������������������60 The auto Keyword ����������������������������������������������������������������������������������������������������������61 Summary ������������������������������������������������������������������������������������������������������������������������62 ■ Chapter 3: Working with Fundamental Data Types ����������������������������������������������65 Operator Precedence and Associativity ��������������������������������������������������������������������������65 Bitwise Operators �����������������������������������������������������������������������������������������������������������67 The Bitwise Shift Operators ������������������������������������������������������������������������������������������������������������������68 Logical Operations on Bit Patterns �������������������������������������������������������������������������������������������������������71 Enumerated Data Types ��������������������������������������������������������������������������������������������������77 Aliases for Data Types ����������������������������������������������������������������������������������������������������80 The Lifetime of a Variable �����������������������������������������������������������������������������������������������81 Global Variables ��������������������������������������������������������������������������������������������������������������82 Summary ������������������������������������������������������������������������������������������������������������������������85 vii ■ Contents ■ Chapter 4: Making Decisions �������������������������������������������������������������������������������89 Comparing Data Values ��������������������������������������������������������������������������������������������������89 Applying the Comparison Operators �����������������������������������������������������������������������������������������������������90 Comparing Floating-Point Values ���������������������������������������������������������������������������������������������������������92 The if Statement �������������������������������������������������������������������������������������������������������������92 Nested if Statements ����������������������������������������������������������������������������������������������������������������������������96 Character Classification and Conversion ����������������������������������������������������������������������������������������������97 The if-else Statement �����������������������������������������������������������������������������������������������������99 Nested if-else Statements ������������������������������������������������������������������������������������������������������������������101 Understanding Nested ifs �������������������������������������������������������������������������������������������������������������������102 Logical Operators ���������������������������������������������������������������������������������������������������������103 Logical AND ����������������������������������������������������������������������������������������������������������������������������������������104 Logical OR �������������������������������������������������������������������������������������������������������������������������������������������104 Logical Negation ���������������������������������������������������������������������������������������������������������������������������������105 Combining Logical Operators �������������������������������������������������������������������������������������������������������������105 Logical Operators on Integer Operands ����������������������������������������������������������������������������������������������107 Logical Operators vs� Bitwise Operators ��������������������������������������������������������������������������������������������108 The Conditional Operator ����������������������������������������������������������������������������������������������110 The switch Statement ��������������������������������������������������������������������������������������������������112 Fallthrough �����������������������������������������������������������������������������������������������������������������������������������������116 Statement Blocks and Variable Scope ��������������������������������������������������������������������������118 Initialization Statements ���������������������������������������������������������������������������������������������������������������������119 Summary ����������������������������������������������������������������������������������������������������������������������120 ■ Chapter 5: Arrays and Loops �����������������������������������������������������������������������������123 Arrays ���������������������������������������������������������������������������������������������������������������������������123 Using an Array ������������������������������������������������������������������������������������������������������������������������������������123 Understanding Loops ���������������������������������������������������������������������������������������������������125 The for Loop �����������������������������������������������������������������������������������������������������������������126 Avoiding Magic Numbers ���������������������������������������������������������������������������������������������128 Defining the Array Size with the Braced Initializer �������������������������������������������������������130 viii ■ Contents Determining the Size of an Array ���������������������������������������������������������������������������������130 Controlling a for Loop with Floating-Point Values ��������������������������������������������������������132 More Complex for Loop Control Expressions ���������������������������������������������������������������135 The Comma Operator ��������������������������������������������������������������������������������������������������������������������������136 The Range-Based for Loop �������������������������������������������������������������������������������������������137 The while Loop �������������������������������������������������������������������������������������������������������������138 The do-while Loop ��������������������������������������������������������������������������������������������������������140 Nested Loops ����������������������������������������������������������������������������������������������������������������142 Skipping Loop Iterations �����������������������������������������������������������������������������������������������145 Breaking Out of a Loop �������������������������������������������������������������������������������������������������146 Indefinite Loops ����������������������������������������������������������������������������������������������������������������������������������146 Controlling a for Loop with Unsigned Integers �������������������������������������������������������������150 Arrays of Characters �����������������������������������������������������������������������������������������������������152 Multidimensional Arrays �����������������������������������������������������������������������������������������������155 Initializing Multidimensional Arrays ����������������������������������������������������������������������������������������������������158 Multidimensional Character Arrays ����������������������������������������������������������������������������������������������������160 Allocating an Array at Runtime �������������������������������������������������������������������������������������161 Alternatives to Using an Array ��������������������������������������������������������������������������������������164 Using array<T,N> Containers �������������������������������������������������������������������������������������������������������������164 Using std::vector<T> Containers ��������������������������������������������������������������������������������������������������������169 Summary ����������������������������������������������������������������������������������������������������������������������174 ■ Chapter 6: Pointers and References ������������������������������������������������������������������177 What Is a Pointer? ��������������������������������������������������������������������������������������������������������177 The Address-Of Operator ����������������������������������������������������������������������������������������������180 The Indirection Operator �����������������������������������������������������������������������������������������������181 Why Use Pointers? �������������������������������������������������������������������������������������������������������183 Pointers to Type char ����������������������������������������������������������������������������������������������������183 Arrays of Pointers �������������������������������������������������������������������������������������������������������������������������������186 Constant Pointers and Pointers to Constants ���������������������������������������������������������������188 ix ■ Contents Pointers and Arrays ������������������������������������������������������������������������������������������������������190 Pointer Arithmetic �������������������������������������������������������������������������������������������������������������������������������191 Using Pointer Notation with an Array Name ���������������������������������������������������������������������������������������193 Dynamic Memory Allocation �����������������������������������������������������������������������������������������196 The Stack and the Free Store �������������������������������������������������������������������������������������������������������������196 Using the new and delete Operators ��������������������������������������������������������������������������������������������������197 Dynamic Allocation of Arrays ��������������������������������������������������������������������������������������������������������������199 Member Selection Through a Pointer ���������������������������������������������������������������������������203 Hazards of Dynamic Memory Allocation �����������������������������������������������������������������������203 Dangling Pointers and Multiple Deallocations ������������������������������������������������������������������������������������204 Allocation/Deallocation Mismatch ������������������������������������������������������������������������������������������������������204 Memory Leaks ������������������������������������������������������������������������������������������������������������������������������������204 Fragmentation of the Free Store ���������������������������������������������������������������������������������������������������������205 Golden Rule of Dynamic Memory Allocation ����������������������������������������������������������������206 Raw Pointers and Smart Pointers ��������������������������������������������������������������������������������206 Using unique_ptr<T> Pointers �����������������������������������������������������������������������������������������������������������208 Using shared_ptr<T> Pointers �����������������������������������������������������������������������������������������������������������211 Understanding References �������������������������������������������������������������������������������������������214 Defining References ���������������������������������������������������������������������������������������������������������������������������214 Using a Reference Variable in a Range-Based for Loop ���������������������������������������������������������������������216 Summary ����������������������������������������������������������������������������������������������������������������������217 ■ Chapter 7: Working with Strings �����������������������������������������������������������������������219 A Better Class of String ������������������������������������������������������������������������������������������������219 Defining string Objects �����������������������������������������������������������������������������������������������������������������������220 Operations with String Objects �����������������������������������������������������������������������������������������������������������223 Accessing Characters in a String��������������������������������������������������������������������������������������������������������228 Accessing Substrings �������������������������������������������������������������������������������������������������������������������������230 Comparing Strings ������������������������������������������������������������������������������������������������������������������������������230 Searching Strings �������������������������������������������������������������������������������������������������������������������������������237 Modifying a String ������������������������������������������������������������������������������������������������������������������������������243 std::string vs� std::vector<char> ��������������������������������������������������������������������������������������������������������248 x

See more

The list of books you might like

Most books are stored in the elastic cloud where traffic is expensive. For this reason, we have a limit on daily download.