Part I The Basics Chapter 2 Hello, World! 43 (>>18763) 2.2 The classic first program 45 (>>18765) 2.3 Compilation 47 Chapter 3 Objects, Types, and Values 59 (>>18766) 3.1 Input 60 (>>18798) 3.2 Variables 62 (>>18805) 3.3 Input and type 64 (>>18813) 3.4 Operations and operators 66 (>>18854) 3.5 Assignment and initialization 69 (>>18856) 3.5.1 An example: detect repeated words 71 (>>18857) 3.6 Composite assignment operators 73 (>>18858) 3.6.1 An example: find repeated words 73 (>>18859) 3.7 Names 74 (>>18910) 3.8 Types and objects 77 (>>18911) 3.9 Type safety 78 (>>18913) 3.9.1 Safe conversions 79 (>>18915) 3.9.2 Unsafe conversions 80 Chapter 4 Computation 89 (>>18920) 4.3 Expressions 94 (>>18922) 4.3.1 Constant expressions 95 (>>18969) 4.3.2 Operators 97 (>>18970) 4.3.3 Conversions 99 (>>18994) 4.4 Statements 100 (>>19044) 4.4.1.1 if-statements 102 (>>19209) 4.4.1.2 switch-statements 105 (>>19213) 4.4.1.3 Switch technicalities 106 (>>19354) 4.4.2.1 while-statements 109 (>>19394) 4.4.2.2 Blocks 111 (>>19395) 4.4.2.3 for-statements 111 (>>19480) 4.5 Functions 113 (>>19491) 4.5.1 Why bother with functions? 115 (>>19492) 4.5.2 Function declarations 117 (>>19606) 4.6 vector 117 (>>19617) 4.6.1 Traversing a vector 119 (>>19619) 4.6.2 Growing a vector 119 (>>19625) 4.6.3 A numeric example 120 (>>19628) 4.6.4 A text example 123 Chapter 5 Errors 133 (>>20392) 5.3.1 Syntax errors 137 (>>20393) 5.3.2 Type errors 138 (>>20395) 5.3.3 Non-errors 139 (>>20447) 5.4 Link-time errors 139 (>>20448) 5.5 Run-time errors 140 (>>20502) 5.5.1 The caller deals with errors 142 (>>20521) 5.5.2 The callee deals with errors 143 (>>20559) 5.5.3 Error reporting 145 (>>20588) 5.6.1 Bad arguments 147 (>>20599) 5.6.2 Range errors 148 (>>20633) 5.6.3 Bad input 150 (>>20681) 5.6.4 Narrowing errors 153 (>>20694) 5.7 Logic errors 154 (>>20696) 5.9.1 Practical debug advice 159 (>>20713) 5.10 Pre- and post-conditions 163 (>>20717) 5.10.1 Post-conditions 165 Chapter 6 Writing a Program 173 (>>21320) 6.1 A problem 174 (>>21324) 6.3 Back to the calculator! 178 (>>21325) 6.3.1 First attempt 179 (>>21327) 6.3.3 Implementing tokens 183 (>>21343) 6.3.4 Using tokens 185 (>>21366) 6.4 Grammars 188 (>>21429) 6.4.1 A detour: English grammar 193 (>>21439) 6.4.2 Writing a grammar 194 (>>21444) 6.5.2.1 Expressions: first try 197 (>>21615) 6.5.2.2 Expressions: second try 198 (>>21636) 6.5.2.3 Expressions: third time lucky 199 (>>21662) 6.5.3 Terms 200 (>>21665) 6.5.4 Primary expressions 202 (>>21666) 6.6 Trying the first version 203 (>>21668) 6.7 Trying the second version 208 (>>21669) 6.8 Token streams 209 (>>21670) 6.8.1 Implementing Token_stream 211 (>>21671) 6.8.2 Reading tokens 212 (>>21672) 6.8.3 Reading numbers 214 (>>21673) 6.9 Program structure 215 Chapter 7 Completing a Program 221 (>>21683) 7.2 Input and output 222 (>>21684) 7.3 Error handling 224 (>>21685) 7.4 Negative numbers 229 (>>21688) 7.5 Remainder: % 230 (>>21689) 7.6.1 Symbolic constants 232 (>>21690) 7.6.2 Use of functions 234 (>>21691) 7.6.3 Code layout 235 (>>21692) 7.6.4 Commenting 237 (>>21693) 7.7 Recovering from errors 239 (>>21695) 7.8.1 Variables and definitions 242 (>>21696) 7.8.2 Introducing names 247 (>>21697) 7.8.3 Predefined names 250 Chapter 8 Technicalities: Functions, etc. 255 (>>21719) 8.2 Declarations and definitions 257 (>>21721) 8.2.2 Variable and constant declarations 262 (>>21722) 8.2.3 Default initialization 263 (>>21723) 8.3 Header files 264 (>>21725) 8.4 Scope 266 (>>21728) 8.5.1 Declaring arguments and return type 272 (>>21729) 8.5.2 Returning a value 274 (>>21730) 8.5.3 Pass-by-value 275 (>>21731) 8.5.4 Pass-by-const-reference 276 (>>21733) 8.5.5 Pass-by-reference 279 (>>21736) 8.5.6 Pass-by-value vs. pass-by-reference 281 (>>21737) 8.5.7 Argument checking and conversion 284 (>>21738) 8.5.8 Function call implementation 285 (>>21739) 8.5.9 constexpr functions 290 (>>21740) 8.6 Order of evaluation 291 (>>21741) 8.6.1 Expression evaluation 292 (>>21742) 8.6.2 Global initialization 293 (>>21743) 8.7 Namespaces 294 (>>21744) 8.7.1 using declarations and using directives 296 Chapter 9 Technicalities: Classes, etc. 303 (>>21780) 9.2 Classes and members 305 (>>21781) 9.3 Interface and implementation 306 (>>21783) 9.4.1 struct and functions 308 (>>21784) 9.4.2 Member functions and constructors 310 (>>21786) 9.4.3 Keep details private 312 (>>21788) 9.4.4 Defining member functions 314 (>>21790) 9.4.5 Referring to the current object 317 (>>21791) 9.4.6 Reporting errors 317 (>>21792) 9.5 Enumerations 318 (>>21793) 9.5.1 “Plain” enumerations 320 (>>21794) 9.6 Operator overloading 321 (>>21795) 9.7.1 Argument types 324 (>>21797) 9.7.2 Copying 326 (>>21798) 9.7.3 Default constructors 327 (>>21801) 9.7.4 const member functions 330 (>>21802) 9.7.5 Members and “helper functions” 332 (>>21803) 9.8 The Date class 334

(>>18750) Part II Input and Output Chapter 10 Input and Output Streams 345 (>>21816) 10.4 Opening a file 350 (>>21819) 10.5 Reading and writing a file 352 (>>21820) 10.6 I/O error handling 354 (>>21823) 10.7 Reading a single value 358 (>>21825) 10.7.1 Breaking the problem into manageable parts 359 (>>21828) 10.7.2 Separating dialog from function 362 (>>21829) 10.8 User-defined output operators 363 (>>21830) 10.9 User-defined input operators 365 (>>21831) 10.10 A standard input loop 365 (>>21832) 10.11.1 In-memory representation 368 (>>21833) 10.11.2 Reading structured values 370 (>>21834) 10.11.3 Changing representations 374 Chapter 11 Customizing Input and Output 379 (>>21863) 11.2.1 Integer output 381 (>>21864) 11.2.2 Integer input 383 (>>21865) 11.2.3 Floating-point output 384 (>>21866) 11.2.4 Precision 385 (>>21867) 11.2.5 Fields 387 (>>21868) 11.3.1 File open modes 388 (>>21869) 11.3.2 Binary files 390 (>>21870) 11.3.3 Positioning in files 393 (>>21871) 11.4 String streams 394 (>>21872) 11.5 Line-oriented input 395 (>>21873) 11.6 Character classification 396 (>>21874) 11.7 Using nonstandard separators 398

>"Here is a version of the classic first program. It writes “Hello, World!” to your screen." The basic rite-of-passage for every programmer tbh. --- >p45 command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_02/main_p45.*****p && ./a.out Hello, World! --- >p45 example code: https://rentry.org/PPP2_p45 https://coliru.stacked-crooked.com/a/59c8f4911d363bc1

>"You’ll find that compilers are rather picky about syntax. Leaving out any detail of our program, such as an #include file, a semicolon, or a curly brace, will cause errors. Similarly, the compiler has absolutely zero tolerance for spelling mistakes." This is an abbreviated set of examples from this section (but please feel free to try the others). You should get the point well enough, namely: computers are very picky! :^) --- >p48a command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_02/main_p48a.*****p && ./a.out main.*****p: In function 'int main()': main.*****p:7:3: error: 'cout' was not declared in this scope 7 | cout << "Hello, World!\n"; | ^~~~ >p48b command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_02/main_p48b.*****p && ./a.out Hello, World! --- >p48a example code https://rentry.org/PPP2_p48a https://coliru.stacked-crooked.com/a/61c18d23b902c91b >p48b example code https://rentry.org/PPP2_p48b https://coliru.stacked-crooked.com/a/d3d2a460ef465ed0

>"Using a string variable, we can read a string from input and write it out again like this" Variables are simply named locations in the computer's memory which hold some kind of data. But...you first need to get that data in there somehow, right Anon? --- >p60 command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_03/main_p60.*****p && ./a.out Please enter your first name (followed by 'enter'): Hello, ! --- >p60 example code https://rentry.org/PPP2_p60 https://coliru.stacked-crooked.com/a/0e0a8817dac8fa72

>"Basically, we can do nothing of interest with a computer without storing data in memory, the way we did it with the input string in the example above." A variable is a named object with a specific type, such as int, string, or double. It also has a set of operators defined for it, such as '+', '==', or '<<'. --- >p63 command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_03/main_p63.*****p && ./a.out 39 3.5 . Annemarie 1 --- >p63 example code https://rentry.org/PPP2_p63 https://coliru.stacked-crooked.com/a/2acc228a586aa683

>"The input operation >> (“get from”) is sensitive to type; that is, it reads according to the type of variable you read into." --- >p64a command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_03/main_p64a.*****p && ./a.out Please enter your first name and age Hello, (age 0) >p64b command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_03/main_p64b.*****p && ./a.out Please enter your first name and age Hello, ??? (age -1) --- >p64a example code https://rentry.org/PPP2_p64a https://coliru.stacked-crooked.com/a/e41bf0f5838087b7 >p64b example code https://rentry.org/PPP2_p64b https://coliru.stacked-crooked.com/a/7d69c0e05f9042a6

>>18805 >"A string read using >> is (by default) terminated by whitespace; that is, it reads a single word. But sometimes, we want to read more than one word. [] For example, we can read a name consisting of two words like this" --- >p65 command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_03/main_p65.*****p && ./a.out Please enter your first and second names Hello, --- >p65 example code https://rentry.org/PPP2_p65 https://coliru.stacked-crooked.com/a/6537db3a8f817248

>"In addition to specifying what values can be stored in a variable, the type of a variable determines what operations we can apply to it and what they mean." --- >p66 command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_03/main_p66.*****p && ./a.out Please enter your count and name 32601 32603 Jr. 32599 -100 --- >p66 example code https://rentry.org/PPP2_p66 https://coliru.stacked-crooked.com/a/3fb2c9cd51d504dc

>>18813 >"The key points here are that there are a lot of useful operators and that their meaning tends to be the same for similar types." --- >p67 command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_03/main_p67.*****p && ./a.out Please enter a floating-point value: n == 0 n + 1 == 1 three times n == 0 twice n == 0 n squared == 0 half of n == 0 square root of n == 0 --- >p67 example code https://rentry.org/PPP2_p67 https://coliru.stacked-crooked.com/a/bac8ffb30be42526 --- >reference/further reading: https://en.*****preference.com/w/*****p/numeric/math/sqrt

>>18815 >"For strings + means concatenation" >"Comparison of strings is particularly useful" --- >p68a command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_03/main_p68a.*****p && ./a.out Please enter your first and second names Hello, >p68b command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_03/main_p68b.*****p && ./a.out Please enter two names that's the same name twice --- >p68a example code https://rentry.org/PPP2_p68a https://coliru.stacked-crooked.com/a/b8bfede64c9d65b7 >p68a example code https://rentry.org/PPP2_p68b https://coliru.stacked-crooked.com/a/7570b01423bcc7db --- >reference/further reading: https://en.*****preference.com/w/*****p/string/basic_string/operator%2B https://en.*****preference.com/w/*****p/string/basic_string/operator_cmp

>"In many ways, the most interesting operator is assignment, represented as = . It gives a variable a new value." --- >p69 command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_03/main_p69.*****p && ./a.out 3 4 4 9 11 --- >p69 example code https://rentry.org/PPP2_p69 https://coliru.stacked-crooked.com/a/423251937f6fbdb8 --- >reference/further reading: https://en.*****preference.com/w/*****p/language/operator_assignment https://en.*****preference.com/w/*****p/language/initialization

>>18854 >"We can also illustrate assignments using strings" >"These operations are so similar that C++ allows us to use the same notation (the = ) for both" --- >p70a command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_03/main_p70a.*****p && ./a.out alpha beta beta betagamma betadelta >p70a command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_03/main_p70b.*****p && ./a.out 8 9 howdy! G'day --- >p70a example code https://rentry.org/PPP2_p70a https://coliru.stacked-crooked.com/a/10936e18f29a65ff >p70b example code https://rentry.org/PPP2_p70b https://coliru.stacked-crooked.com/a/54953ea16c5e364a

>"When you think of it, it is obvious that assignment is most useful when you do things many times. We need an assignment when we want to do something again with a different value" previous = current; is the statement to note here (in the context of the while() loop). --- >p71 command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_03/main_p71.*****p && ./a.out Please enter words --- >p71 example code https://rentry.org/PPP2_p71 https://coliru.stacked-crooked.com/a/0bff213731fbce9b --- >reference/further reading: https://en.*****preference.com/w/*****p/language/operator_comparison

>"Incrementing a variable (that is, adding 1 to it) is so common in programs that C++ provides a special syntax for it." >"There are many other common ways of changing the value of a variable based on its current value." --- >p73a command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_03/main_p73a.*****p && ./a.out 2 3 8 -8 2 --- >p73a example code https://rentry.org/PPP2_p73a https://coliru.stacked-crooked.com/a/a025c53654d077c3

>"Consider the example of detecting repeated adjacent words above. We could improve that by giving an idea of where the repeated word was in the sequence. A simple variation of that idea simply counts the words and outputs the count for the repeated word" Remember Anon, ctrl+d ends typing in an input stream composed of strings. --- >p73b command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_03/main_p73b.*****p && ./a.out Please enter words --- >p73b example code https://rentry.org/PPP2_p73b https://coliru.stacked-crooked.com/a/fc74b888c313413c

>"In a C++ program, a name starts with a letter and contains only letters, digits, and underscores." >"Names are case sensitive; that is, uppercase and lowercase letters are distinct, so x and X are different names. This little program has at least four errors" --- >p75a command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_03/main_p75a.*****p && ./a.out 1 1 1 1 1 >p75b command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_03/main_p75b.*****p && ./a.out main.*****p: In function 'int Main()': main.*****p:6:3: error: 'STRING' was not declared in this scope 6 | STRING s = "Goodbye, cruel world! "; | ^~~~~~ main.*****p:7:3: error: 'cOut' was not declared in this scope 7 | cOut << S << '\n'; | ^~~~ main.*****p:7:11: error: 'S' was not declared in this scope 7 | cOut << S << '\n'; | ^ main.*****p:8:1: warning: no return statement in function returning non-void [-Wreturn-type] 8 | } --- >p75a example code https://rentry.org/PPP2_p75a https://coliru.stacked-crooked.com/a/55685ec719badd19 >p75b example code https://rentry.org/PPP2_p75b https://coliru.stacked-crooked.com/a/7f28fe28aaf306b9 --- >reference/further reading: https://en.*****preference.com/w/*****p/language/identifiers

>>18859 >"The C++ language reserves many (about 85) names as “keywords.” We list them in §A.3.1. You can’t use those to name your variables, types, functions, etc." >"When you choose names for your variables, functions, types, etc., choose meaningful names; that is, choose names that will help people understand your program." --- >p76 command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_03/main_p76.*****p && ./a.out 7 7 7 7 7 7 7 7 7 --- >p76 example code https://rentry.org/PPP2_p76 https://coliru.stacked-crooked.com/a/68a80f7b86b05b2b

>"The notion of type is central to C++ and most other programming languages." >"Informally, we think of an object as a box into which we can put values of a given type." --- >p76 command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_03/main_p77.*****p && ./a.out 7 9 a 1.2 Hello, World! 1.2 --- >p76 example code https://rentry.org/PPP2_p77 https://coliru.stacked-crooked.com/a/f5bd5a237572ef15

>"Every object is given a type when it is defined. A program — or a part of a program — is type-safe when objects are used only according to the rules for their type." --- >p78 command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_03/main_p78.*****p && ./a.out main.*****p: In function 'int main()': main.*****p:9:10: warning: unused variable 'y' [-Wunused-variable] 9 | double y = x; // the value of y is undefined | ^ main.*****p:10:10: warning: unused variable 'z' [-Wunused-variable] 10 | double z = 2.0 + x; // the meaning of + and the value of z are undefined | ^ main.*****p:9:10: warning: 'x' is used uninitialized [-Wuninitialized] 9 | double y = x; // the value of y is undefined | ^ main.*****p:6:10: note: 'x' was declared here 6 | double x; // we “forgot” to initialize: | ^ --- >p78 example code https://rentry.org/PPP2_p78 https://coliru.stacked-crooked.com/a/1a5a6ed70cfde407

>"When needed, a char is converted to an int and an int is converted to a double." >"The most useful conversion is int to double because it allows us to mix ints and doubles in expressions" --- >p79 command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_03/main_p79.*****p && ./a.out x 120 x 120 2.3 4.3 --- >p79 example code https://rentry.org/PPP2_p79 https://coliru.stacked-crooked.com/a/35e69f0a3e4c3624

>"Safe conversions are usually a boon to the programmer and simplify writing code. Unfortunately, C++ also allows for (implicit) unsafe conversions. By unsafe, we mean that a value can be implicitly turned into a value of another type that does not equal the original value." --- >p80 command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_03/main_p80.*****p && ./a.out oops!: 20000 != 32 --- >p80 example code https://rentry.org/PPP2_p80 https://coliru.stacked-crooked.com/a/b84450420557f5a5

>>18915 >"The problem is that an int is typically much larger than a char, so that it can (and in this case does) hold an int value that cannot be represented as a char. Try it to see what value b gets on your machine (32 is a common result); better still, experiment" --- >p81 command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_03/main_p81.*****p && ./a.out Please enter numbers --- >p81 example code https://rentry.org/PPP2_p81 https://coliru.stacked-crooked.com/a/947eddfdcf90abae

>>18916 >"They are unsafe in the sense that the value stored might differ from the value assigned. Why can this be a problem? Because often we don’t suspect that an unsafe conversion is taking place." --- >p82 command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_03/main_p82.*****p && ./a.out NOTE: JSON encoding for the output failed due to invalid UTF8. --- >p82 example code https://rentry.org/PPP2_p82 https://coliru.stacked-crooked.com/a/08096f80d81515f2

>"The most basic building block of programs is an expression. An expression computes a value from a number of operands." --- >p94 command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_04/main_p94.*****p && ./a.out 20 40 800 99 40 3960 --- >p94 example code https://rentry.org/PPP2_p94 https://coliru.stacked-crooked.com/a/b8c1fff9ac5ca91e

>>18920 >"We can make more complicated expressions by combining expressions using operators, such as + and *, in just the way that we are used to. When needed, we can use parentheses to group expressions:" --- >p95 command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_04/main_p95.*****p && ./a.out 99 40 3960 278 --- >p95 example code https://rentry.org/PPP2_p95 https://coliru.stacked-crooked.com/a/976c68aaf836cee8

>"C++ offers the notion of a symbolic constant, that is, a named object to which you can’t give a new value after it has been initialized." --- >p96a command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_04/main_p96a.*****p && ./a.out 3.14159 2 12.5664 --- >p96a example code https://rentry.org/PPP2_p96a https://coliru.stacked-crooked.com/a/5e249645b408da96

>>18922 >"In some places, such as case labels (§4.4.1.3), C++ requires a constant expression, that is, an expression with an integer value composed exclusively of constants." --- >p96b command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_04/main_p96b.*****p && ./a.out 17 19 19 21 --- >p96b example code https://rentry.org/PPP2_p96b https://coliru.stacked-crooked.com/a/5e249645b408da96

>>18938 >"A constexpr symbolic constant must be given a value that is known at compile time." --- >p96c command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_04/main_p96c.*****p && ./a.out 100 42 107 --- >p96c example code https://rentry.org/PPP2_p96c https://coliru.stacked-crooked.com/a/4a7fc4cf28d4baf8

>>18939 >"To handle cases where the value of a “variable” that is initialized with a value that is not known at compile time but never changes after initialization, C++ offers a second form of constant (a const)" --- >p97 command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_04/main_p97.*****p && ./a.out 100 42 107 49 --- >p97 example code https://rentry.org/PPP2_p97 https://coliru.stacked-crooked.com/a/e3f3830ec1726d33

>"An increment can be expressed in at least three ways" --- >p98 command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_04/main_p98.*****p && ./a.out 10 11 12 13 --- >p98 example code https://rentry.org/PPP2_p98 https://coliru.stacked-crooked.com/a/2e18ad073fba6a68

>"The rule (for the types we have presented so far) is that if an operator has an operand of type double, we use floating-point arithmetic yielding a double result; otherwise, we use integer arithmetic yielding an int result." --- >p99a command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_04/main_p99a.*****p && ./a.out 2 1.25 98 --- >p99a example code https://rentry.org/PPP2_p99a https://coliru.stacked-crooked.com/a/dbe748ac03036975

>>18970 >"Once the result has been calculated, the compiler may have to convert it (again) to use it as an initializer or the right hand of an assignment." --- >p99b command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_04/main_p99b.*****p && ./a.out 2.5 2 1.25 1 --- >p99b example code https://rentry.org/PPP2_p99b https://coliru.stacked-crooked.com/a/ec6378ed52f8a863

>>18971 >"Beware that it is easy to forget about integer division in an expression that also contains floating-point operands." --- >p100a command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_04/main_p100a.*****p && ./a.out Please enter a temperature centigrade: 32 --- >p100a example code https://rentry.org/PPP2_p100a https://coliru.stacked-crooked.com/a/ca450ec75d54e93f

>>18991 >"To get the code mathematically correct, either 9 or 5 (or both) will have to be changed into a double." --- >p100b command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_04/main_p100b.*****p && ./a.out Please enter a temperature centigrade: 32 --- >p100b example code https://rentry.org/PPP2_p100b https://coliru.stacked-crooked.com/a/5ad53a662bdbf615

>"So far, we have seen two kinds of statements: expression statements and declarations. An expression statement is simply an expression followed by a semicolon." --- >p100c command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_04/main_p100c.*****p && ./a.out 2 3 --- >p100c example code https://rentry.org/PPP2_p100c https://coliru.stacked-crooked.com/a/f5ecf0292dbd4f9d

>>18994 >"When statements follow each other, the computer executes them in the order in which they are written." >"In general, we want a statement to have some effect. Statements without effect are typically useless." --- >p101a command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_04/main_p101a.*****p && ./a.out 7 --- >p101a example code https://rentry.org/PPP2_p101a https://coliru.stacked-crooked.com/a/d80b2f2716dc8d93

>>19042 >"In other words, the if-statement doesn’t matter; y is going to get the value 3 regardless. This is a common error for novice programmers, and it can be difficult to spot, so watch out for it." --- >p101b command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_04/main_p101b.*****p && ./a.out 4 3 5 3 --- >p101b example code https://rentry.org/PPP2_p101b https://coliru.stacked-crooked.com/a/62e18b56ef1cad00

>"The simplest form of selection is an if-statement, which selects between two alternatives." >"If its condition is true, the first statement is executed; otherwise, the second statement is. This notion is simple." --- >p102a command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_04/main_p102a.*****p && ./a.out Please enter two integers max(0,0) is 0 --- >p102a example code https://rentry.org/PPP2_p102a https://coliru.stacked-crooked.com/a/2de0ed01f4807fbc

>>19044 >"For example, you were probably told in kindergarten that to cross the street at a traffic light, you had to wait for the light to turn green: “If the traffic light is green, go” and “If the traffic light is red, wait.”" --- >p102b command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_04/main_p102b.*****p && ./a.out go wait --- >p102b example code https://rentry.org/PPP2_p102b https://coliru.stacked-crooked.com/a/d946869567d63dba

>>19045 >"Consider what’s wrong with this program" >"The snag is that we didn’t test for bad input. The program assumes that the user enters proper input." --- >p103a command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_04/main_p103a.*****p && ./a.out Please enter a length followed by a separate unit (c or i): 1cm == 0.393701in --- >p103a example code https://rentry.org/PPP2_p103a https://coliru.stacked-crooked.com/a/d946869567d63dba

>>19187 >"We must always test our programs with “bad” input, because someone will eventually — intentionally or accidentally — enter bad input. A program should behave sensibly even if its users don’t." --- >p103b command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_04/main_p103b.*****p && ./a.out Please enter a length followed by a separate unit (c or i): Sorry, I don't know a unit called ' ' --- >p103b example code https://rentry.org/PPP2_p103b https://coliru.stacked-crooked.com/a/eb7b1867fedfe11f

>"Actually, the comparison of unit to 'i' and to 'c' is an example of the most common form of selection: a selection based on comparison of a value against several constants. Such selection is so common that C++ provides a special statement for it: the switch-statement." --- >p105 command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_04/main_p105.*****p && ./a.out Please enter a length followed by a separate unit (c or i): Sorry, I don't know a unit called 'a' --- >p105 example code https://rentry.org/PPP2_p105 https://coliru.stacked-crooked.com/a/d34612ea142a90c7

>"1. The value on which we switch must be of an integer, char, or enumeration (§9.5) type. In particular, you cannot switch on a string. >2. The values in the case labels must be constant expressions (§4.3.1). In particular, you cannot use a variable in a case label. >3. You cannot use the same value for two case labels. >4. You can use several case labels for a single case. >5. Don’t forget to end each case with a break. Unfortunately, the compiler probably won’t warn you if you forget." --- >p106 command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_04/main_p106.*****p && ./a.out main.*****p: In function 'int main()': main.*****p:17:11: error: switch quantity not an integer 17 | switch (s) { // error: the value must be of integer, char, or enum type | ^ --- >p106 example code https://rentry.org/PPP2_p106 https://coliru.stacked-crooked.com/a/34877add4e01bcfa

>>19213 >"A switch-statement generates optimized code for comparing against a set of constants. For larger sets of constants, this typically yields more efficient code than a collection of if-statements. However, this means that the case label values must be constants and distinct." --- >p107a command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_04/main_p107a.*****p && ./a.out main.*****p: In function 'int main()': main.*****p:24:10: error: the value of 'y' is not usable in a constant expression 24 | case y: // error: variable in case label | ^ main.*****p:13:18: note: 'int y' is not const 13 | int y = 'y'; // this is going to cause trouble | ^ main.*****p:24:10: error: the value of 'y' is not usable in a constant expression 24 | case y: // error: variable in case label | ^ main.*****p:13:18: note: 'int y' is not const 13 | int y = 'y'; // this is going to cause trouble | ^ main.*****p:30:5: error: duplicate case value 30 | case 'n': // error: duplicate case label (n’s value is ‘n’) | ^~~~ main.*****p:21:5: note: previously used here 21 | case n: | ^~~~ --- >p107a example code https://rentry.org/PPP2_p107a https://coliru.stacked-crooked.com/a/813ea02d272bf2ef

>>19255 >"Often you want the same action for a set of values in a switch. It would be tedious to repeat the action so you can label a single action by a set of case labels." --- >p107b command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_04/main_p107b.*****p && ./a.out Please enter a digit is not a digit --- >p107b example code https://rentry.org/PPP2_p107b https://coliru.stacked-crooked.com/a/68e462e8a9296fa8

>>19277 >"The most common error with switch-statements is to forget to terminate a case with a break." >"Unfortunately, the compiler will accept this, and when you have finished case 'i' you’ll just “drop through” into case 'c' " --- >p108 command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_04/main_p108.*****p && ./a.out Please enter a length followed by a separate unit (c or i): --- >p108 example code https://rentry.org/PPP2_p108 https://coliru.stacked-crooked.com/a/d4cc54c9affa11f0

>"As an example of iteration, consider the first program ever to run on a stored-program computer (the EDSAC)." >"[It will] calculate and print a simple list of squares" --- >p109 command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_04/main_p109.*****p && ./a.out 0 0 1 1 2 4 3 9 ... 97 9409 98 9604 99 9801 --- >p109 example code https://rentry.org/PPP2_p109 https://coliru.stacked-crooked.com/a/238ba83913557d28

>"A sequence of statements delimited by curly braces { and } is called a block or a compound statement. A block is a kind of statement." >"The empty block { } is sometimes useful for expressing that nothing is to be done." --- >p111 command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_04/main_p111.*****p && ./a.out 0 0 1 1 2 4 3 9 ... 97 9409 98 9604 99 9801 0 1 --- >p111 example code https://rentry.org/PPP2_p111 https://coliru.stacked-crooked.com/a/8f6b4b1736724580

>"Iterating over a sequence of numbers is so common that C++, like most other programming languages, has a special syntax for it. A for-statement is like a while-statement except that the management of the control variable is concentrated at the top where it is easy to see and understand." --- >p112a command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_04/main_p112a.*****p && ./a.out 0 0 1 1 2 4 3 9 ... 97 9409 98 9604 99 9801 0 0 1 1 2 4 3 9 ... 97 9409 98 9604 99 9801 --- >p112a example code https://rentry.org/PPP2_p112a https://coliru.stacked-crooked.com/a/989a42064bbdb6f6

>>19395 >"[U]sing a for-statement yields more easily understood and more maintainable code whenever a loop can be defined as a for-statement with a simple initializer, condition, and increment operation. Use a while-statement only when that’s not the case." >"Never modify the loop variable inside the body of a for-statement. That would violate every reader’s reasonable assumption about what a loop is doing." You'll see instead how to properly do a 'by-twos' for loop in the next post; in case that's what you actually wanted, Anon. --- >p112b command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_04/main_p112b.*****p && ./a.out 0 0 2 4 4 16 6 36 ... 94 8836 96 9216 98 9604 --- >p112b example code https://rentry.org/PPP2_p112b https://coliru.stacked-crooked.com/a/74b8d74e145d3f93

>>19396 >"If you want to increment by 2, say so" >"Please note that the cleaner, more explicit version is shorter than the messy one. That’s typical." --- >p113a command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_04/main_p113a.*****p && ./a.out 0 0 2 4 4 16 6 36 ... 94 8836 96 9216 98 9604 --- >p113a example code https://rentry.org/PPP2_p113a https://coliru.stacked-crooked.com/a/e671476b46997bdf

>"In the program above, what was square(i)? It is a call of a function. In particular, it is a call of the function called square with the argument i. A function is a named sequence of statements. A function can return a result (also called a return value)." >"The first line of this definition tells us that this is a function (that’s what the parentheses mean), that it is called square, that it takes an int argument (here, called x), and that it returns an int (the type of the result always comes first in a function declaration)" --- >p113b command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_04/main_p113b.*****p && ./a.out 4 100 --- >p113b example code https://rentry.org/PPP2_p113b https://coliru.stacked-crooked.com/a/66ff7556f4b021a3

>>19480 >"We don’t have to use the result of a function call, but we do have to give a function exactly the arguments it requires." >"You might think that a computer should be smart enough to figure out that by the string "two" you really meant the integer 2." >"However, a C++ compiler deliberately isn’t that smart. It is the compiler’s job to do exactly what you tell it to do after verifying that your code is well formed according to the definition of C++." --- >p114 command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_04/main_p114.*****p && ./a.out main.*****p: In function 'int main()': main.*****p:12:18: error: too few arguments to function 'int square(int)' 12 | int v1 = square(); // error: argument missing | ~~~~~~^~ main.*****p:5:5: note: declared here 5 | int square(int x) // return the square of x | ^~~~~~ main.*****p:13:12: error: invalid conversion from 'int (*)(int)' to 'int' [-fpermissive] 13 | int v2 = square; // error: parentheses missing | ^~~~~~ | | | int (*)(int) main.*****p:14:18: error: too many arguments to function 'int square(int)' 14 | int v3 = square(1, 2); // error: too many arguments | ~~~~~~^~~~~~ main.*****p:5:5: note: declared here 5 | int square(int x) // return the square of x | ^~~~~~ main.*****p:15:19: error: invalid conversion from 'const char*' to 'int' [-fpermissive] 15 | int v4 = square("two"); // error: wrong type of argument – int expected | ^~~~~ | | | const char* main.*****p:5:16: note: initializing argument 1 of 'int square(int)' 5 | int square(int x) // return the square of x | ~~~~^ main.*****p:12:7: warning: unused variable 'v1' [-Wunused-variable] 12 | int v1 = square(); // error: argument missing | ^~ main.*****p:13:7: warning: unused variable 'v2' [-Wunused-variable] 13 | int v2 = square; // error: parentheses missing | ^~ main.*****p:14:7: warning: unused variable 'v3' [-Wunused-variable] 14 | int v3 = square(1, 2); // error: too many arguments | ^~ main.*****p:15:7: warning: unused variable 'v4' [-Wunused-variable] 15 | int v4 = square("two"); // error: wrong type of argument – int expected | ^~ --- >p114 example code https://rentry.org/PPP2_p114 https://coliru.stacked-crooked.com/a/dbf15fbf1030dd6d

>>19481 >"The list of arguments required by the function is called a parameter list and its elements are called parameters (or formal arguments). The list of parameters can be empty, and if we don’t want to return a result we give void (meaning “nothing”) as the return type." --- >p115 command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_04/main_p115.*****p && ./a.out Sorry --- >p115 example code https://rentry.org/PPP2_p115 https://coliru.stacked-crooked.com/a/8106dad15357049e

>"We define a function when we want a separate computation with a name because doing so >• Makes the computation logically separate >• Makes the program text clearer (by naming the computation) >• Makes it possible to use the function in more than one place in our program >• Eases testing" >"Why didn’t we use the version using print_square()? That version is not significantly simpler than the version using square(), and note that >• print_square() is a rather specialized function that we could not expect to be able to use later, whereas square() is an obvious candidate for other uses >• square() hardly requires documentation, whereas print_square() obviously needs explanation" --- >p116 command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_04/main_p116.*****p && ./a.out 0 0 1 1 2 4 3 9 ... 97 9409 98 9604 99 9801 --- >p116 example code https://rentry.org/PPP2_p116 https://coliru.stacked-crooked.com/a/a6f4a1df1ae50ae8

>"We don’t really need to look at the function body. In real programs, we most often don’t want to look at a function body." >"Fortunately, C++ provides a way of supplying that information separate from the complete function definition. It is called a function declaration" >"So, if you just want to use a function, you simply write — or more commonly #include — its declaration. The function definition can be elsewhere." --- >p117 command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_04/main_p117.*****p && ./a.out 1936 --- >p117 example code https://rentry.org/PPP2_p117 https://coliru.stacked-crooked.com/a/0ddffe4e9580180b

>"To do just about anything of interest in a program, we need a collection of data to work on." >"For example, we might need a list of phone numbers, a list of members of a football team, a list of courses, a list of books read over the last year, a catalog of songs for download, a set of payment options for a car, a list of the weather forecasts for the next week, a list of prices for a camera in different web stores, etc." >"Here we will start with one of the simplest, and arguably the most useful, ways of storing data: a vector." >"A vector is simply a sequence of elements that you can access by an index." --- >p118a command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_04/main_p118a.*****p && ./a.out 5 7 9 4 6 8 Kant Plato Hume Kierkegaard --- >p118a example code https://rentry.org/PPP2_p118a https://coliru.stacked-crooked.com/a/70e74a6b95384cdb

>>19606 >"Naturally, a vector will only accept elements of its declared element type:" --- >p118b command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_04/main_p118b.*****p && ./a.out main.*****p: In function 'int main()': main.*****p:20:21: error: invalid conversion from 'const char*' to '__gnu_cxx::__alloc_traits<std::allocator<int>, int>::value_type' {aka 'int'} [-fpermissive] 20 | v[2] = "Hume"; // error: trying to assign a string to an int | ^~~~~~ | | | const char* --- >p118b example code https://rentry.org/PPP2_p118b https://coliru.stacked-crooked.com/a/bb3b980150272962

>>19609 >"We can also define a vector of a given size without specifying the element values." >"In that case, we use the (n) notation where n is the number of elements, and the elements are given a default value according to the element type." --- >p118c command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_04/main_p118c.*****p && ./a.out 0 0 0 0 0 0 "" "" "" "" --- >p118c example code https://rentry.org/PPP2_p118c https://coliru.stacked-crooked.com/a/a1491a3374bfb7af

>>19614 >"Please note that you cannot simply refer to a nonexistent element of a vector" >"We will discuss run-time errors and subscripting in the next chapter." --- >p119a command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_04/main_p119a.*****p && ./a.out main.*****p: In function 'int main()': main.*****p:12:13: warning: array subscript 20000 is outside array bounds of 'int [6]' [-Warray-bounds] 12 | vi[20000] = 44; // run-time error In file included from /usr/local/include/c++/12.1.0/x86_64-pc-linux-gnu/bits/c++allocator.h:33, from /usr/local/include/c++/12.1.0/bits/allocator.h:46, from /usr/local/include/c++/12.1.0/vector:61, from main.*****p:5: In member function '_Tp* std::__new_allocator<_Tp>::allocate(size_type, const void*) [with _Tp = int]', inlined from 'constexpr _Tp* std::allocator< <template-parameter-1-1> >::allocate(std::size_t) [with _Tp = int]' at /usr/local/include/c++/12.1.0/bits/allocator.h:183:40, inlined from 'static constexpr _Tp* std::allocator_traits<std::allocator<_Up> >::allocate(allocator_type&, size_type) [with _Tp = int]' at /usr/local/include/c++/12.1.0/bits/alloc_traits.h:464:28, inlined from 'constexpr std::_Vector_base<_Tp, _Alloc>::pointer std::_Vector_base<_Tp, _Alloc>::_M_allocate(std::size_t) [with _Tp = int; _Alloc = std::allocator<int>]' at /usr/local/include/c++/12.1.0/bits/stl_vector.h:378:33, inlined from 'constexpr std::_Vector_base<_Tp, _Alloc>::pointer std::_Vector_base<_Tp, _Alloc>::_M_allocate(std::size_t) [with _Tp = int; _Alloc = std::allocator<int>]' at /usr/local/include/c++/12.1.0/bits/stl_vector.h:375:7, inlined from 'constexpr void std::_Vector_base<_Tp, _Alloc>::_M_create_storage(std::size_t) [with _Tp = int; _Alloc = std::allocator<int>]' at /usr/local/include/c++/12.1.0/bits/stl_vector.h:395:44, inlined from 'constexpr std::_Vector_base<_Tp, _Alloc>::_Vector_base(std::size_t, const allocator_type&) [with _Tp = int; _Alloc = std::allocator<int>]' at /usr/local/include/c++/12.1.0/bits/stl_vector.h:332:26, inlined from 'constexpr std::vector<_Tp, _Alloc>::vector(size_type, const allocator_type&) [with _Tp = int; _Alloc = std::allocator<int>]' at /usr/local/include/c++/12.1.0/bits/stl_vector.h:552:47, inlined from 'int main()' at main.*****p:10:19: /usr/local/include/c++/12.1.0/bits/new_allocator.h:137:55: note: at offset 80000 into object of size 24 allocated by 'operator new' 137 | return static_cast<_Tp*>(_GLIBCXX_OPERATOR_NEW(__n * sizeof(_Tp))); | ^ --- >p119a example code https://rentry.org/PPP2_p119a https://coliru.stacked-crooked.com/a/b9b0ec78e7d45648

>"A vector “knows” its size, so we can print the elements of a vector like this" >"The call v.size() gives the number of elements of the vector called v. In general, v.size() gives us the ability to access elements of a vector without accidentally referring to an element outside the vector’s range." >"The range for a vector v is [0:v.size()). That’s the mathematical notation for a half-open sequence of elements." --- >p119b command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_04/main_p119b.*****p && ./a.out 5 7 9 4 6 8 --- >p119b example code https://rentry.org/PPP2_p119b https://coliru.stacked-crooked.com/a/a9b2a8bb366e22d7

>>19617 >"The language takes advantage of the notion of a half-open sequence to provide a simple loop over all the elements of a sequence, such as the elements of a vector." >"This is called a range-for-loop because the word range is often used to mean the same as “sequence of elements.” We read for (int x : v) as “for each int x in v” and the meaning of the loop is exactly like the equivalent loop over the subscripts [0:v.size())." >tl;dr Use range-for-loops instead, whenever you're able to Anon! :^) --- >p119c command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_04/main_p119c.*****p && ./a.out 5 7 9 4 6 8 --- >p119c example code https://rentry.org/PPP2_p119c https://coliru.stacked-crooked.com/a/01c4e58fd42f9976

>"Often, we start a vector empty and grow it to its desired size as we read or compute the data we want in it. The key operation here is push_back(), which adds a new element to a vector. The new element becomes the last element of the vector." --- >p120 command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_04/main_p120.*****p && ./a.out 2.7 5.6 7.9 --- >p120 example code https://rentry.org/PPP2_p120 https://coliru.stacked-crooked.com/a/6d84240e374bcf3b

>"Often, we have a series of values that we want to read into our program so that we can do something with them. The “something” could be producing a graph of the values, calculating the mean and median, finding the largest element, sorting them, combining them with other data, searching for “interesting” values, comparing them to other data, etc." >"There is no limit to the range of computations we might perform on data, but first we need to get it into our computer’s memory." >"As a concrete example, we chose to read in floating-point numbers representing temperatures" --- >p121 command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_04/main_p121.*****p && ./a.out Please enter temperatures: --- >p121 example code https://rentry.org/PPP2_p121 https://coliru.stacked-crooked.com/a/6ba0936a9226bfd0

∫>>19621 >"To limit the scope of our input variable, temp, to the loop, we used a for-statement, rather than a while-statement" --- >p122a command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_04/main_p122a.*****p && ./a.out Please enter temperatures: --- >p122a example code https://rentry.org/PPP2_p122a https://coliru.stacked-crooked.com/a/ed1134f8abfb6ff7

>>19625 >"Once we get data into a vector we can easily manipulate it. As an example, let’s calculate the mean and median temperatures:" --- >p122b command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_04/main_p122b.*****p && ./a.out Please enter temperatures: Average temperature: 0 Median temperature: 0 --- >p122b example code https://rentry.org/PPP2_p122b https://coliru.stacked-crooked.com/a/4bfcdb62497290b2

>"From a programmer’s point of view, what’s interesting about this example is its generality: the vector and the simple operations on it can be used in a huge range of applications. It is fair to say that whatever you are interested in, if you need to analyze data, you’ll use vector (or a similar data structure; see Chapter 21)." >"As an example, let’s build a simple dictionary" Stop. Try to understand this example in detail before moving on through the textbook, Anon. If you can do so, then it's fair to say you've completely understood this chapter. It wraps up most every technique used so far into one short program! :^) --- >p123 command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_04/main_p123.*****p && ./a.out Please enter words: Number of words: 0 --- >p123 example code https://rentry.org/PPP2_p123 https://coliru.stacked-crooked.com/a/0d777141f1114798 >le epin 1337 h4x04z version: https://coliru.stacked-crooked.com/a/7ebb4d7ade022842 :^)

>"Each of those lines has a syntax error; that is, they are not well formed according to the C++ grammar, so the compiler will reject them." >"Unfortunately, syntax errors are not always easy to report in a way that you, the programmer, find easy to understand." >"That’s because the compiler may have to read a bit further than the error to be sure that there really is an error." >tl;dr Error messages can sometimes be really difficult to discern what's going on. I recommend going directly to the top of the list of messages if you have a long listing. That's usually the most important message to pay attention to, Anon (YMMV). --- >p137 command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_05/main_p137.*****p && ./a.out main.*****p:15:17: warning: character constant too long for its type 15 | int s4 = area('7); // error: non-terminated character ( ' missing) | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ main.*****p: In function 'int main()': main.*****p:12:18: error: expected ')' before ';' token 12 | int s1 = area(7; // error: ) missing | ~ ^ | ) main.*****p:13:16: error: too few arguments to function 'int area(int, int)' 13 | int s2 = area(7) // error: ; missing | ~~~~^~~ main.*****p:9:5: note: declared here 9 | int area(int length, int width); // calculate area of a rectangle | ^~~~ main.*****p:15:60: error: expected ')' before 'missing' 15 | int s4 = area('7); // error: non-terminated character ( ' missing) | ~ ^~~~~~~~ | ) main.*****p:15:16: error: too few arguments to function 'int area(int, int)' 15 | int s4 = area('7); // error: non-terminated character ( ' missing) | ~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ main.*****p:9:5: note: declared here 9 | int area(int length, int width); // calculate area of a rectangle | ^~~~ main.*****p:12:7: warning: unused variable 's1' [-Wunused-variable] 12 | int s1 = area(7; // error: ) missing | ^~ main.*****p:13:7: warning: unused variable 's2' [-Wunused-variable] 13 | int s2 = area(7) // error: ; missing | ^~ main.*****p:15:7: warning: unused variable 's4' [-Wunused-variable] 15 | int s4 = area('7); // error: non-terminated character ( ' missing) | ^~ --- >p137 example code https://rentry.org/PPP2_p137 https://coliru.stacked-crooked.com/a/8b33ba99077c9ca2

>"Once you have removed syntax errors, the compiler will start reporting type errors; that is, it will report mismatches between the types you declared (or forgot to declare) for your variables, functions, etc. and the types of values or expressions you assign to them, pass as function arguments, etc." --- >p138 command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_05/main_p138.*****p && ./a.out main.*****p: In function 'int main()': main.*****p:12:12: error: 'arena' was not declared in this scope; did you mean 'area'? 12 | int x0 = arena(7); // error: undeclared function | ^~~~~ | area main.*****p:13:16: error: too few arguments to function 'int area(int, int)' 13 | int x1 = area(7); // error: wrong number of arguments | ~~~~^~~ main.*****p:9:5: note: declared here 9 | int area(int length, int width); // calculate area of a rectangle | ^~~~ main.*****p:14:17: error: invalid conversion from 'const char*' to 'int' [-fpermissive] 14 | int x2 = area("seven", 2); // error: 1st argument has a wrong type | ^~~~~~~ | | | const char* main.*****p:9:14: note: initializing argument 1 of 'int area(int, int)' 9 | int area(int length, int width); // calculate area of a rectangle | ~~~~^~~~~~ --- >p138 example code https://rentry.org/PPP2_p138 https://coliru.stacked-crooked.com/a/7836d7ca764e8f41

>"As you work with the compiler, you’ll wish that it was smart enough to figure out what you meant; that is, you’d like some of the errors it reports not to be errors. That’s natural." >"More surprisingly, as you gain experience, you’ll begin to wish that the compiler would reject more code, rather than less." >"As you gain experience, you’ll learn how to get the most out of the compiler’s ability to detect errors and to dodge its known weaknesses." --- >p139 command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_05/main_p139.*****p && ./a.out NOTE: JSON encoding for the output failed due to invalid UTF8. --- >p139 example code https://rentry.org/PPP2_p139 https://coliru.stacked-crooked.com/a/4e208c39fb870e87

>"A program consists of several separately compiled parts, called translation units. Every function in a program must be declared with exactly the same type in every translation unit in which it is used. We use header files to ensure that; see §8.3." >"Every function must also be defined exactly once in a program. If either of these rules is violated, the linker will give an error." --- >p140 command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_05/main_p140.*****p && ./a.out 6 --- >p140 example code https://rentry.org/PPP2_p140 https://coliru.stacked-crooked.com/a/bd60a2f17048e65e

>"If your program has no compile-time errors and no link-time errors, it’ll run." >"This is where the fun really starts." >"look at the calculation of the ratio in the code []. It looks innocent enough. Did you notice something wrong with it?" --- >p141 command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_05/main_p141.*****p && ./a.out -1 2 4 -2 -2 0 -inf --- >p141 example code https://rentry.org/PPP2_p141 https://coliru.stacked-crooked.com/a/126ae3d0f145a9d7

>"So, let’s tackle the problem of argument errors with area(). We have two obvious alternatives: >a. Let the caller of area() deal with bad arguments. >b. Let area() (the called function) deal with bad arguments." >"Let’s try the first alternative (“Let the user beware!”) first. That’s the one we’d have to choose if area() was a function in a library where we couldn’t modify it. For better or worse, this is the most common approach." --- >p142a command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_05/main_p142a.*****p && ./a.out terminate called after throwing an instance of 'std::runtime_error' what(): non-positive x bash: line 7: 28398 Aborted (core dumped) ./a.out --- >p142a example code https://rentry.org/PPP2_p142a https://coliru.stacked-crooked.com/a/e647b0adbcd448bb

>>20502 >"If we didn’t need separate error messages about each argument, we would simplify" --- >p142b command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_05/main_p142b.*****p && ./a.out terminate called after throwing an instance of 'std::runtime_error' what(): non-positive area() argument bash: line 7: 30987 Aborted (core dumped) ./a.out --- >p142b example code https://rentry.org/PPP2_p142b https://coliru.stacked-crooked.com/a/750f8a83b22cd37f

>>20504 >"To complete protecting area() from bad arguments, we have to deal with the calls through framed_area()." >"This is messy, but there is also something fundamentally wrong. We could write this only by knowing exactly how framed_area() used area()." >"We shouldn’t have to know such details!" --- >p142c command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_05/main_p142c.*****p && ./a.out terminate called after throwing an instance of 'std::runtime_error' what(): non-positive 2nd area() argument called by framed_area() bash: line 7: 308 Aborted (core dumped) ./a.out --- >p142c example code https://rentry.org/PPP2_p142c https://coliru.stacked-crooked.com/a/a978fafa9fd5fe5b

>>20505 >"We could make the code less brittle by giving the value subtracted by framed_area() a name. That name [can also] be used by code calling framed_area()" >"Look at that code! Are you sure it is correct? Do you find it pretty? Is it easy to read? Actually, we find it ugly (and therefore error-prone). We have more than trebled the size of the code and exposed an implementation detail of framed_area()." >"There has to be a better way!" --- >p143a command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_05/main_p143a.*****p && ./a.out terminate called after throwing an instance of 'std::runtime_error' what(): non-positive argument for area() called by framed_area() bash: line 7: 32136 Aborted (core dumped) ./a.out --- >p143a example code https://rentry.org/PPP2_p143a https://coliru.stacked-crooked.com/a/2e05cbb6e7c08d5b

>"Checking for valid arguments within framed_area() is easy, and error() can still be used to report a problem:" >"if anything to do with the error handling changes, we only have to modify the code in one place." >"One benefit of [this] approach is that the argument-checking code is in one place. We don’t have to search the whole program for calls. Furthermore, that one place is exactly where the arguments are to be used, so all the information we need is easily available for us to do the check." --- >p143b command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_05/main_p143b.*****p && ./a.out terminate called after throwing an instance of 'std::runtime_error' what(): non-positive area() argument called by framed_area() bash: line 7: 17344 Aborted (core dumped) ./a.out --- >p143b example code https://rentry.org/PPP2_p143b https://coliru.stacked-crooked.com/a/5278b381370f893f

>"Let’s consider a slightly different question: Once you have checked a set of arguments and found an error, what should you do? Sometimes you can return an “error value.”" >"[This] way, we can have the called function do the detailed checking, while letting each caller handle the error as desired." --- >p145 command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_05/main_p145.*****p && ./a.out Are all x of y?? (yes or no) b 0 0 -1 --- >p145 example code https://rentry.org/PPP2_p145 https://coliru.stacked-crooked.com/a/e0e714ca69e53f91

>>20559 >"The [case of a caller forgetting to test] can easily lead to surprises." >"Do you see the errors? This kind of error is hard to find because there is no obvious “wrong code” to look at: the error is the absence of [tests in the caller-function f() ]." --- >p146 command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_05/main_p146.*****p && ./a.out terminate called after throwing an instance of 'std::runtime_error' what(): non-positive area bash: line 7: 23929 Aborted (core dumped) ./a.out --- >p146 example code https://rentry.org/PPP2_p146 https://coliru.stacked-crooked.com/a/657385f3e23664c6

>"C++ provides a mechanism to help deal with errors: exceptions. The fundamental idea is to separate detection of an error (which should be done in a called function) from the handling of an error (which should be done in the calling function) while ensuring that a detected error cannot be ignored" >"Nothing makes error handling easy, but exceptions make it easier." >"Here is a version of area() using exceptions" >"if the arguments are OK, we return the area as always; if not, we get out of area() using the throw, hoping that some catch will provide an appropriate response." --- >p147 command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_05/main_p147.*****p && ./a.out Oops! bad arguments to area() --- >p147 example code https://rentry.org/PPP2_p147 https://coliru.stacked-crooked.com/a/22a54fef98e27d13

>"The most common and useful standard library container is the vector we introduced in §4.6. A vector holds a number of elements, and we can determine that number by calling the vector’s size() member function." >"What happens if we try to use an element with an index (subscript) that isn’t in the valid range [0:v.size())?" --- >p148 command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_05/main_p148.*****p && ./a.out Please enter integers: (enter '|' to stop): bash: line 7: 1002 Segmentation fault (core dumped) ./a.out --- >p148 example code https://rentry.org/PPP2_p148 https://coliru.stacked-crooked.com/a/e69b44b0d2368c2a

>>20599 >"Here is a simpler version that produces the same [type of] range error as the loop" --- >p149a command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_05/main_p149a.*****p && ./a.out main.*****p: In function 'int main()': main.*****p:13:22: warning: array subscript 5 is outside array bounds of 'int [5]' [-Warray-bounds] 13 | int x = v[5]; | ^ In file included from /usr/local/include/c++/12.1.0/x86_64-pc-linux-gnu/bits/c++allocator.h:33, from /usr/local/include/c++/12.1.0/bits/allocator.h:46, from /usr/local/include/c++/12.1.0/string:41, from /usr/local/include/c++/12.1.0/bits/locale_classes.h:40, from /usr/local/include/c++/12.1.0/bits/ios_base.h:41, from /usr/local/include/c++/12.1.0/ios:42, from /usr/local/include/c++/12.1.0/ostream:38, from /usr/local/include/c++/12.1.0/iostream:39, from main.*****p:5: In member function '_Tp* std::__new_allocator<_Tp>::allocate(size_type, const void*) [with _Tp = int]', inlined from 'constexpr _Tp* std::allocator< <template-parameter-1-1> >::allocate(std::size_t) [with _Tp = int]' at /usr/local/include/c++/12.1.0/bits/allocator.h:183:40, inlined from 'static constexpr _Tp* std::allocator_traits<std::allocator<_CharT> >::allocate(allocator_type&, size_type) [with _Tp = int]' at /usr/local/include/c++/12.1.0/bits/alloc_traits.h:464:28, inlined from 'constexpr std::_Vector_base<_Tp, _Alloc>::pointer std::_Vector_base<_Tp, _Alloc>::_M_allocate(std::size_t) [with _Tp = int; _Alloc = std::allocator<int>]' at /usr/local/include/c++/12.1.0/bits/stl_vector.h:378:33, inlined from 'constexpr std::_Vector_base<_Tp, _Alloc>::pointer std::_Vector_base<_Tp, _Alloc>::_M_allocate(std::size_t) [with _Tp = int; _Alloc = std::allocator<int>]' at /usr/local/include/c++/12.1.0/bits/stl_vector.h:375:7, inlined from 'constexpr void std::_Vector_base<_Tp, _Alloc>::_M_create_storage(std::size_t) [with _Tp = int; _Alloc = std::allocator<int>]' at /usr/local/include/c++/12.1.0/bits/stl_vector.h:395:44, inlined from 'constexpr std::_Vector_base<_Tp, _Alloc>::_Vector_base(std::size_t, const allocator_type&) [with _Tp = int; _Alloc = std::allocator<int>]' at /usr/local/include/c++/12.1.0/bits/stl_vector.h:332:26, inlined from 'constexpr std::vector<_Tp, _Alloc>::vector(size_type, const allocator_type&) [with _Tp = int; _Alloc = std::allocator<int>]' at /usr/local/include/c++/12.1.0/bits/stl_vector.h:552:47, inlined from 'int main()' at main.*****p:12:18: /usr/local/include/c++/12.1.0/bits/new_allocator.h:137:55: note: at offset 20 into object of size 20 allocated by 'operator new' 137 | return static_cast<_Tp*>(_GLIBCXX_OPERATOR_NEW(__n * sizeof(_Tp))); | ^ 0 --- >p149a example code https://rentry.org/PPP2_p149a https://coliru.stacked-crooked.com/a/808ae10aafad386d

>>20628 >if the off-by-one code above had been part of a program that caught exceptions, we would at least have gotten a decent error message" >"Note that a range error is really a special case of the argument errors we discussed in §5.5.2." --- >p149b command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_05/main_p149b.*****p && ./a.out Please enter integers: (press '|' to stop): Oops! Range error --- >p149b example code https://rentry.org/PPP2_p149b https://coliru.stacked-crooked.com/a/09a4691fbca9c8de

>"We can test if the last input operation succeeded by testing cin" >"During the early stages of development, we often want to indicate that we have found an error but aren’t yet ready to do anything particularly clever about it; we just want to report the error and terminate the program." >"Later, maybe, we’ll come back and do something more appropriate." --- >p150 command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_05/main_p150.*****p && ./a.out Please enter a float: Exception: runtime error, couldn't read a double in 'some_function()' --- >p150 example code https://rentry.org/PPP2_p150 https://coliru.stacked-crooked.com/a/4706d0fd7580b7ad

>>20633 >"The standard library defines a few types of exceptions, such as the out_of_range thrown by vector. It also supplies runtime_error which is pretty ideal for our needs because it holds a string that can be used by an error handler." >"When we want to deal with runtime_error we simply catch it. For simple programs, catching runtime_error in main() is ideal" >"The call e.what() extracts the error message from the runtime_error." --- >p151 command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_05/main_p151.*****p && ./a.out --- >p151 example code https://rentry.org/PPP2_p151 https://coliru.stacked-crooked.com/a/7e229dde5940715f

>>20635 >"As it happens, out_of_range is not a runtime_error, so catching runtime_error does not deal with the out_of_range errors that we might get from misuse of vectors and other standard library container types." >"However, both out_of_range and runtime_ error are “exceptions,” so we can catch exception to deal with both" >"We added catch(...) to handle exceptions of any type whatsoever." --- >p152a command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_05/main_p152a.*****p && ./a.out --- >p152a example code https://rentry.org/PPP2_p152a https://coliru.stacked-crooked.com/a/f2c1eeef1e452d20

>>20668 >"When you use error(), you’ll often wish to pass two pieces of information along to describe the problem. In that case, just concatenate the strings describing those two pieces of information. This is so common that we provide a second version of error() for that" --- >p152b command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_05/main_p152b.*****p && ./a.out --- >p152b example code https://rentry.org/PPP2_p152b https://coliru.stacked-crooked.com/a/8389ea9a1bb2edc0

>"In §3.9.2 we saw a nasty kind of error: when we assign a value that’s “too large to fit” to a variable, it is implicitly truncated." >"Here x will get the value 2 rather than 2.9, because x is an int and ints don’t have values that are fractions of an integer, just whole integers (obviously). Similarly, if we use the common ASCII character set, c will get the value 42 (representing the character *), rather than 1066, because there is no char with the value 1066 in that character set." --- >p153a command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_05/main_p153a.*****p && ./a.out main.*****p: In function 'int main()': main.*****p:11:12: warning: overflow in conversion from 'int' to 'char' changes value from '1066' to ''*'' [-Woverflow] 11 | char c = 1066; | ^~~~ 2 * --- >p153a example code https://rentry.org/PPP2_p153a https://coliru.stacked-crooked.com/a/cc4575cb9c2eed73

>>20681 >"In §3.9.2 we saw how we could protect ourselves against such narrowing by testing. Given exceptions (and templates; see §19.3) we can write a function that tests and throws a runtime_error exception if an assignment or initialization would lead to a changed value." --- >p153b command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_05/main_p153b.*****p && ./a.out error: info loss 2.900000 -> 2 --- >p153b example code https://rentry.org/PPP2_p153b https://coliru.stacked-crooked.com/a/66617d63dfca1f03

>"Logic errors are usually the most difficult to find and eliminate, because [after successfully building,] the computer does [just] what you asked it to." >"Your job now is to figure out why that wasn’t really what you meant." >"Basically, a computer is a very fast moron. It does exactly what you tell it to do, and that can be most humbling." --- >p154 command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_05/main_p154.*****p && ./a.out Please enter temperatures: (enter '|' to stop): High temperature: 0 Low temperature: 0 Average temperature: -nan --- >p154 example code https://rentry.org/PPP2_p154 https://coliru.stacked-crooked.com/a/e76ebab53bdefc92

>>20694 >"Unfortunately, there are [] errors in [that] program. What would happen if all of the temperatures were below zero? The initialization for high_temp has the equivalent problem to low_temp: high_temp will remain at 0.0 unless there is a higher temperature in the data. This program wouldn’t work for the South Pole in winter either." >"These errors are fairly typical; they will not cause any errors when you compile the program or cause wrong results for “reasonable” inputs." >"However, we forgot to think about what we should consider “reasonable”. Here is an improved program" --- >p156 command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_05/main_p156.*****p && ./a.out Please enter temperatures: (enter '|' to stop): High temperature: -1000 Low temperature: 1000 Average temperature: -nan --- >p156 example code https://rentry.org/PPP2_p156 https://coliru.stacked-crooked.com/a/e436ab6b69b9e1ab

>"Occasionally, you will feel that the rules the compiler enforces are stupid and unnecessary (they rarely are) and that things could and ought to be simpler (indeed, but they are not)." >"However, as they say, “a poor craftsman curses his tools.” A good craftsman knows the strengths and weaknesses of his tools and adjusts his work accordingly." >"Here are some common compile-time errors" --- >p161 command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_05/main_p161.*****p && ./a.out --- >p161 example code https://rentry.org/PPP2_p161 https://coliru.stacked-crooked.com/a/f812cd1db7942123

>>20696 >"When looking for a bug, carefully follow the code statement by statement from the last point that you are sure it was correct. Pretend you’re the computer executing the program. Does the output match your expectations? Of course not, or you wouldn’t be debugging." >"Often, when you don’t see the problem, the reason is that you “see” what you expect to see rather than what you [actually] wrote." --- >p162a command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_05/main_p162a.*****p && ./a.out --- >p162a example code https://rentry.org/PPP2_p162a https://coliru.stacked-crooked.com/a/4a4f523688cfe4ca

>>20710 >"Eventually, you’ll learn to use [sophisticated debugging] facilities, but for simple problems and simple programs, you can just temporarily put in a few extra output statements (using cerr) to help you see what’s going on." --- >p162b command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_05/main_p162b.*****p && ./a.out my_fct(1,2.2) my_fct() returns 0 --- >p162b example code https://rentry.org/PPP2_p162b https://coliru.stacked-crooked.com/a/6c4de5acaa797625

>"Insert statements that check invariants (that is, conditions that should always hold; see §9.4.3) in sections of code suspected of harboring bugs." >"A statement that states (asserts) an invariant is called an assertion (or just an assert)." --- >p163 command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_05/main_p163.*****p && ./a.out error: bad arguments for mcf --- >p163 example code https://rentry.org/PPP2_p163 https://coliru.stacked-crooked.com/a/8b2b7982a1ecc138

>>20713 >"The question is just what to do if the pre-condition is violated (doesn’t hold). We basically have two choices: > 1. Ignore it (hope/assume that all callers give correct arguments). > 2. Check it (and report the error somehow). >Looking at it this way, argument types are just a way of having the compiler check the simplest pre-conditions for us and report them at compile time." --- >p164 command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_05/main_p164.*****p && ./a.out main.*****p: In function 'int main()': main.*****p:28:41: error: invalid conversion from 'const char*' to 'int' [-fpermissive] 28 | int x = my_complicated_function(1, 2, "horsefeathers"); | ^~~~~~~~~~~~~~~ | | | const char* main.*****p:17:47: note: initializing argument 3 of 'int my_complicated_function(int, int, int)' 17 | int my_complicated_function(int a, int b, int c) | ~~~~^ --- >p164 example code https://rentry.org/PPP2_p164 https://coliru.stacked-crooked.com/a/efd0502282551205

>>20715 >"Writing pre-conditions (even as comments) also has a significant benefit for the quality of your programs: it forces you to think about what a function requires." >"If you can’t state that simply and precisely in a couple of comment lines, you probably haven’t thought hard enough about what you are doing." >"We did mention that we hated debugging; explicitly stating pre-conditions helps in avoiding design errors as well as catching usage errors early." >"Writing [the more complex function] saves you time and grief compared with the apparently simpler [function]" --- >p165a command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_05/main_p165a.*****p && ./a.out main.*****p: In function 'int main()': main.*****p:36:41: error: invalid conversion from 'const char*' to 'int' [-fpermissive] 36 | int x = my_complicated_function(1, 2, "horsefeathers"); | ^~~~~~~~~~~~~~~ | | | const char* main.*****p:29:47: note: initializing argument 3 of 'int my_complicated_function(int, int, int)' 29 | int my_complicated_function(int a, int b, int c) { | ~~~~^ --- >p165a example code https://rentry.org/PPP2_p165a https://coliru.stacked-crooked.com/a/9ef43fc55973c536

>"[The commented-out function here] checks its pre-condition, but it doesn’t state it in the comment (that may be OK for such a short function) and it assumes that the computation is correct (that’s probably OK for such a trivial computation)." >"However, we could be a bit more explicit" >"Pre- and post-conditions provide basic sanity checks in code. As such they are closely connected to the notion of invariants (§9.4.3), correctness (§4.2, §5.2), and testing (Chapter 26)." Stop. Try and understand this example fully, Anon. If you can, then you're well on your way to understanding errors and how to detect them! :^) --- >p165b command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_05/main_p165b.*****p && ./a.out error: area() pre-condition --- >p165b example code https://rentry.org/PPP2_p165b https://coliru.stacked-crooked.com/a/4b423050b038f172

Example code to demonstrate multifile builds using Coliru. >see the mini FAQ explanation ITT if needed (>>18749) note: Remember to clear the command line of each extra file before sharing it, Anon. :^) --- >command line + possible output: ln -s /Archive2/97/69e1b3dc7af21f/main.*****p Foo.h ln -s /Archive2/33/abc01b07a06392/main.*****p Foo.*****p g++ -std=c++20 -O2 -Wall -pedantic Foo.*****p main.*****p && ./a.out ctor'd a Foo --- >example code https://rentry.org/PPP2_foo_main https://rentry.org/PPP2_foo_h https://rentry.org/PPP2_foo_*****p https://coliru.stacked-crooked.com/a/1f5491740d5e0dcd https://coliru.stacked-crooked.com/a/9769e1b3dc7af21f https://coliru.stacked-crooked.com/a/33abc01b07a06392

This is a rendition of Bjarne's basic mathematical calculator project into a maintainable format. The project spans two full chapters in the book, and is presented in a very methodical, bottom-up approach to reasoning about how to solve everything step-by-step. The primary focus of the project is to teach you how to parse formal Language Grammars using your new programming skills. It's presented ITT here in advance before those chapters, so that you can 'look ahead' and get an idea where it's all going. If you're ever scratching your head trying to figure out one of the steps (to come), you can always look back here to see how it was solved in the end. BTW, this is a working calculator. Try different entries for the here string arguments at the end of the command line below. >(protip: simply modify what's already given as an example) You can just follow the link below to Coliru and tinker around with things there. Caution As a novice, it's not intended that you understand how all this works yet (though you will before long). For now, its simply posted here as a reference to assist with understanding the answers to some questions that will pop up for you as you work through these 2 chapters of the book. So glance at it if you care to, otherwise just refer back here afterwards as-needed. The textbook's material picks up a couple posts ahead at § 6.1 A problem - p175 (>>21320), so you can just skip over to there instead if you'd like. Cheers. --- >Calculator project command line + possible output: ln -s /Archive2/b4/f1e7d567fd6bd2/main.*****p Calculator.h ln -s /Archive2/68/52ff216ce3687f/main.*****p calc_util.h ln -s /Archive2/56/2e219ca8d64e0b/main.*****p Calculator.*****p ln -s /Archive2/68/b228c371f01ef5/main.*****p calc_util.*****p g++ -std=c++20 -O2 -Wall -pedantic calc_util.*****p Calculator.*****p main.*****p && ./a.out <<< '1+2; 5%8; 2*(3/4-5); q' > = 3 > = 5 > = -8.5 > --- >Calculator project example code https://rentry.org/PPP2_calculator_cli https://coliru.stacked-crooked.com/a/213a22dd10a6f316

>>21307 >Calculator.h https://rentry.org/PPP2_Calculator_h https://coliru.stacked-crooked.com/a/b4f1e7d567fd6bd2 >calc_util.h https://rentry.org/PPP2_calc_util_h https://coliru.stacked-crooked.com/a/6852ff216ce3687f

>>21312 >Calculator.*****p https://rentry.org/PPP2_Calculator_*****p https://coliru.stacked-crooked.com/a/562e219ca8d64e0b >calc_util.*****p https://rentry.org/PPP2_calc_util_*****p https://coliru.stacked-crooked.com/a/68b228c371f01ef5

>"Writing a program starts with a problem; that is, you have a problem that you’d like a program to help solve." >"Understanding that problem is key to a good program." >"At this stage [of the book], what would be a good program to look at?" >"We chose “Get the computer to do ordinary arithmetic on expressions we type in”; that is, we want to write a simple calculator." --- >p175 command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_06/main_p175.*****p && ./a.out 14.4 --- >p175 example code https://rentry.org/PPP2_p175 https://coliru.stacked-crooked.com/a/32d99c70644a8855

>"How do we want to interact with the calculator?" >"That’s easy: we know how to use cin and cout, but graphical user interfaces (GUIs) are not explained until Chapter 16, so we’ll stick to the keyboard and a console window." >"Given expressions as input from the keyboard, we evaluate them and write out the resulting value to the screen." --- >p178 command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_06/main_p178.*****p && ./a.out 4 8 0 --- >p178 example code https://rentry.org/PPP2_p178 https://coliru.stacked-crooked.com/a/19ba9c3f6e04adf4

>"At this point, we are not really ready to write the calculator program." >"We simply haven’t thought hard enough, but thinking is hard work and – like most programmers – we are anxious to write some code." >"So let’s take a chance, write a simple calculator, and see where it leads us." >"This (sort of) works! So what if this program isn’t quite complete? It feels great to get something running! Maybe this programming and computer science stuff is easier than the rumors say." >"Well, maybe, but let’s not get too carried away by an early success." :^) --- >p179 command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_06/main_p179.*****p && ./a.out Please enter expression (we can handle + and –): Result: 0 --- >p179 example code https://rentry.org/PPP2_p179 https://coliru.stacked-crooked.com/a/fcea610bf65a7100

>>21325 >"In particular, we know that we should always check that our input is reasonable (in our hurry, we “forgot”) and that testing a value against many constants is best done by a switch-statement rather than an if-statement." >"The “chaining” of operations, such as 1+2+3+4, we will handle by adding the values as they are read; that is, we start with 1, see +2 and add 2 to 1 (getting an intermediate result 3), see +3 and add that 3 to our intermediate result (a 6), and so on." --- Stop If you've been doing really well and have understood everything that's going on so far -- or at least most of it heh -- then proceed through with the next post and so on. OTOH, if you're struggling a bit with things, then I suggest you skip over the next few posts and proceed directly to § 6.5.2.1 Expressions: first try (>>21444). This is where the author begins to methodically work out the solutions for the calculator, moving through things one step at a time. It's a more relaxed pace of things tbh. :^) But please at least read through the book from this point (p 180) to p 197 (where we pick back up)! It's OK if you can't understand it all yet through that section, but it's important to at least get your brain used to seeing the ideas. The reason for all this is that in my effort to make most of the programs over the next few posts actually work, I needed to throw in some already-implemented functions so everything would build & run. This is a lot of new information & complexity that's just kind of dropped right into the novice's lap. I apologize for that necessity. Again, if you're struggling then just skip ahead to the provided crosslink, where we'll all pick back up again. See you there Anon! Cheers. :^) --- >p180 command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_06/main_p180.*****p && ./a.out Please enter expression (we can handle +, –, *, and /) add an x to end expression (e.g., 1+2*3x): terminate called after throwing an instance of 'std::runtime_error' what(): no first operand bash: line 7: 5232 Aborted (core dumped) ./a.out --- >p180 example code https://rentry.org/PPP2_p180 https://coliru.stacked-crooked.com/a/d6111bb450d89ffc

>"What should a token look like in our program? In other words, what would we like our Token type to be?" >"A Token must be able to represent operators, such as + and –, and numeric values, such as 42 and 3.14." >"The obvious implementation is something that can represent what “kind” a token is and hold the numeric value for tokens that have one" --- >p183 command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_06/main_p183.*****p && ./a.out 3.14 --- >p183 example code https://rentry.org/PPP2_p183 https://coliru.stacked-crooked.com/a/2aee019423e3b12d

>>21327 >"Note that for simple tokens, such as +, we don’t need the value, so we don’t use its value member." >"We needed a character to mean “number” and picked '8' just because '8' obviously isn’t an operator or a punctuation character. Using '8' to mean “number” is a bit cryptic, but it’ll do for now." >"Token is an example of a C++ user-defined type. A user-defined type can have member functions (operations) as well as data members. There can be many reasons for defining member functions." >"Here, we’ll just provide two member functions to give us a more convenient way of initializing Tokens" --- >p184 command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_06/main_p184.*****p && ./a.out + 0 8 11.5 --- >p184 example code https://rentry.org/PPP2_p184 https://coliru.stacked-crooked.com/a/bd0de0fd063c4d5d

>"How would we use Tokens in the calculator?" >"We can read input into a vector of Tokens" >"we could find the multiply operation by a simple loop" >"Yes, but now what? What do we do with that product d?" --- >p185 command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_06/main_p185.*****p && ./a.out /tmp/ccNN7d2e.o: In function `main': main.*****p:(.text.startup+0x51): undefined reference to `get_token()' collect2: error: ld returned 1 exit status --- >p185 example code https://rentry.org/PPP2_p185 https://coliru.stacked-crooked.com/a/7a76796de26cd2e9

>"There is a standard answer to the question of how to make sense of expressions:" >"first input characters are read and assembled into tokens (as [] discovered)." >"A token is a sequence of characters that represents something we consider a unit, such as a number or an operator." --- >p188 command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_06/main_p188.*****p && ./a.out <<< '45+11.5/7;' Please enter expression (we can handle +, –, *, and /), then add a ; to print (e.g., 1+2*3;): the Tokens are listed as: t.kind : t.value 8 : 45 + : 0 8 : 11.5 / : 0 8 : 7 --- >p188 example code https://rentry.org/PPP2_p188 https://coliru.stacked-crooked.com/a/dcc8175e6af67d5d

>>21366 >"How do you read a grammar? Basically, given some input, you start with the “top rule,” Expression, and search through the rules to find a match for the tokens as they are read." >"Reading a stream of tokens according to a grammar is called parsing, and a program that does that is often called a parser or a syntax analyzer." >"Our parser reads the tokens from left to right, just like we type them and read them." >"Let’s try something really simple: Is 2 an expression?" >"yes, according to our grammar, 2 is an expression. We can illustrate the progression through the grammar [with the parsing tree given.]"' --- >p189 command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_06/main_p189.*****p && ./a.out 2 --- >p189 example code https://rentry.org/PPP2_p189 https://coliru.stacked-crooked.com/a/01d2f651e3a2560c

>>21375 >"Let’s try something a bit more complicated: Is 2+3 an Expression? Naturally, much of the reasoning is the same as for 2" >"Again, we can illustrate this reasoning graphically (leaving out the floating-point literal to Number rule to simplify)" >"[So yes,] an Expression followed by + followed by a Term is an Expression." >"The real reason we are interested in grammars is that they can solve our problem of how to correctly parse expressions"' --- >p191 command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_06/main_p191.*****p && ./a.out <<< '2+3;' enter: 2+3; 5 --- >p191 example code https://rentry.org/PPP2_p191 https://coliru.stacked-crooked.com/a/63d9276ea3015320

>>21403 >"Is 45+11.5*7 an Expression?" >"In particular, it is an Expression that first does the multiplication 11.5*7 [(via the Term*Primary rule),] and then the addition 45+[80.5], just as if we had written 45+(11.5*7)." >"[So yes,] an Expression followed by + followed by a Term*Primary is an Expression." >"we were not really trying [here] to teach you to understand 2+2 or 45+11.5*7. Obviously, you knew that already."' >"We were trying to find a way for the computer to “understand” 45+11.5*7 and all the other complicated expressions you might give it to evaluate." --- >p192 command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_06/main_p192.*****p && ./a.out <<< '45+11.5*7;' enter: 45+11.5*7; 125.5 --- >p192 example code https://rentry.org/PPP2_p192 https://coliru.stacked-crooked.com/a/2a836369dcc3989e

>"If you have never before worked with grammars, we expect that your head is now spinning." >"In fact, it may be spinning even if you have seen a grammar before, but take a look at the [provided] grammar for a very small subset of English" >"A sentence is built from parts of speech (e.g., nouns, verbs, and conjunctions)." >"A sentence can be parsed according to these rules to determine which words are nouns, verbs, etc." --- >p193 command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_06/main_p193.*****p && ./a.out <<< 'birbs fly but fish swim ;' enter: birbs fly but fish swim ; (leave a space before ;) n birbs v fly c but n fish v swim sentence: birbs fly but fish swim ; --- >p193 example code https://rentry.org/PPP2_p193 https://coliru.stacked-crooked.com/a/b65dc739966c68c0

>"How did we pick those expression grammar rules?" >"“Experience” is the honest answer. The way we do it is simply the way people usually write expression grammars." >"However, writing a simple grammar is pretty straightforward" >"We simply put tokens in (double) quotes and start with the first rule. Alternatives are put on separate lines." --- >p195 command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_06/main_p195.*****p && ./a.out <<< '{A, A, A, A, B}' enter: {A, A, A, A, B} { A, A, A, A, B } : this is a valid list --- >p195 example code https://rentry.org/PPP2_p195 https://coliru.stacked-crooked.com/a/d47677084806904d

>"To implement our calculator, we need four functions: one to read tokens plus one for each rule in our grammar:" >"Let’s first write expression()." >"Since this is our first attempt to turn a set of grammar rules into code, we’ll proceed through a couple of false starts. That’s the way it usually goes with new techniques, and we learn useful things along the way." >"In particular, a novice programmer can learn a lot from looking at the dramatically different behavior of similar pieces of code. Reading code is a useful skill to cultivate." --- >p197 command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_06/main_p197.*****p && ./a.out main.*****p: In function 'double expression()': main.*****p:35:8: warning: infinite recursion detected [-Winfinite-recursion] 35 | double expression() { | ^~~~~~~~~~ main.*****p:36:27: note: recursive call 36 | double left = expression(); // read and evaluate an Expression | ~~~~~~~~~~^~ /tmp/ccDIgtqr.o: In function `expression()': main.*****p:(.text+0x10): undefined reference to `get_token()' main.*****p:(.text+0x31): undefined reference to `term()' main.*****p:(.text+0x51): undefined reference to `term()' collect2: error: ld returned 1 exit status --- >p197 example code https://rentry.org/PPP2_p197 https://coliru.stacked-crooked.com/a/c5a4d33f0784f7a9

>"In fact, this expression() will never get beyond its first line: expression() starts by calling expression() which starts by calling expression() and so on “forever.”" >"This is called an infinite recursion and will in fact terminate after a short while when the computer runs out of memory to hold the “never-ending” sequence of calls of expression()." >"The term recursion is used to describe what happens when a function calls itself. Not all recursions are infinite, and recursion is a very useful programming technique (see §8.5.8)." >"So what do we do? Every Term is an Expression, but not every Expression is a Term; that is, we could start looking for a Term and look for a full Expression only if we found a + or a –." --- >p198 command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_06/main_p198.*****p && ./a.out /tmp/cceRLSTF.o: In function `expression()': main.*****p:(.text+0x5): undefined reference to `term()' main.*****p:(.text+0x10): undefined reference to `get_token()' collect2: error: ld returned 1 exit status --- >p198 example code https://rentry.org/PPP2_p198 https://coliru.stacked-crooked.com/a/f5188f612b4533c5

>"So we got a very nice program that just didn’t do the right thing. That’s dangerous." >"It is especially dangerous because it gives the right answer in many cases. For example, 1+2+3 gives the right answer (6) because 1+(2+3) equals (1+2)+3." >"What fundamentally, from a programming point of view, did we do wrong? We should always ask ourselves this question when we have found an error. That way we might avoid making the same mistake again, and again, and again." >"Fundamentally, we just looked at the code and guessed. That’s rarely good enough!" >"So, what now?" >"Look again at the grammar (the correct grammar in §6.5.2): any Expression starts with a Term and such a Term can be followed by a + or a –. So, we have to look for a Term, see if it is followed by a + or a –, and keep doing that until there are no more plusses or minuses." --- >p199 command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_06/main_p199.*****p && ./a.out /tmp/ccFvCha2.o: In function `expression()': main.*****p:(.text+0x5): undefined reference to `term()' main.*****p:(.text+0x10): undefined reference to `get_token()' main.*****p:(.text+0x25): undefined reference to `term()' main.*****p:(.text+0x3a): undefined reference to `get_token()' main.*****p:(.text+0x43): undefined reference to `term()' collect2: error: ld returned 1 exit status --- >p199 example code https://rentry.org/PPP2_p199 https://coliru.stacked-crooked.com/a/6812e3612948b70b

>>21636 >"This is a bit messier: we had to introduce a loop to keep looking for plusses and minuses. We also got a bit repetitive: we test for + and – twice and twice call get_token()." >"Because it obscures the logic of the code, let’s just get rid of the duplication of the test for + and –" >"What we have done is to remove the mention of expression() within expression() and replace it with a loop. In other words, we translated the Expression in the grammar rules for Expression into a loop looking for a Term followed by a + or a –." This last bit mentioned is a very key technique used here, for how to approach this entire concept generally. Please be sure you understand it before proceeding Anon. :^) --- >p200 command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_06/main_p200.*****p && ./a.out /tmp/ccQYnbix.o: In function `expression()': main.*****p:(.text+0x5): undefined reference to `term()' main.*****p:(.text+0x10): undefined reference to `get_token()' main.*****p:(.text+0x31): undefined reference to `term()' main.*****p:(.text+0x49): undefined reference to `term()' collect2: error: ld returned 1 exit status --- >p200 example code https://rentry.org/PPP2_p200 https://coliru.stacked-crooked.com/a/3fe7fdbfd496ad2d

>"The grammar rule for Term is very similar to the Expression rule consequently, the code should be very similar also." >"Unfortunately, this doesn’t compile: the remainder operation (%) is not defined for floating-point numbers." >"we could simply leave % out of our calculator. Let’s take the simplest choice for now." >"However, an experienced programmer will notice an undesirable detail that makes [this version of] term() unacceptable. What would happen if you entered 2/0?" --- >p201 command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_06/main_p201.*****p && ./a.out /tmp/ccdJLsdO.o: In function `term()': main.*****p:(.text+0x5): undefined reference to `primary()' main.*****p:(.text+0x10): undefined reference to `get_token()' main.*****p:(.text+0x31): undefined reference to `primary()' main.*****p:(.text+0x49): undefined reference to `primary()' /tmp/ccdJLsdO.o: In function `expression()': main.*****p:(.text+0x70): undefined reference to `get_token()' collect2: error: ld returned 1 exit status --- >p201 example code https://rentry.org/PPP2_p201 https://coliru.stacked-crooked.com/a/d5a29d12c851f072

>>21662 >"You can’t divide by zero." >"If you try, the computer hardware will detect it and terminate your program with a somewhat unhelpful error message." >"So, we’d better check and give a decent error message" >"Why did we put the statements handling / into a block? The compiler insists." >"If you want to define and initialize variables within a switch-statement, you must place them inside a block." --- >p202 command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_06/main_p202.*****p && ./a.out /tmp/cc4ZfTd7.o: In function `term()': main.*****p:(.text+0x7): undefined reference to `primary()' main.*****p:(.text+0x12): undefined reference to `get_token()' main.*****p:(.text+0x31): undefined reference to `primary()' main.*****p:(.text+0x49): undefined reference to `primary()' /tmp/cc4ZfTd7.o: In function `expression()': main.*****p:(.text+0x80): undefined reference to `get_token()' collect2: error: ld returned 1 exit status --- >p202 example code https://rentry.org/PPP2_p202 https://coliru.stacked-crooked.com/a/c6d3a7d9cc585a10

>"The grammar rule for primary expressions is also simple" >"The code that implements it is a bit messy because there are more opportunities for syntax errors" >"Basically there is nothing new compared to expression() and term(). We use the same language primitives, the same way of dealing with Tokens, and the same programming techniques." --- >p203a command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_06/main_p203a.*****p && ./a.out /tmp/ccFR2TxI.o: In function `term()': main.*****p:(.text+0x11): undefined reference to `get_token()' /tmp/ccFR2TxI.o: In function `expression()': main.*****p:(.text+0xb0): undefined reference to `get_token()' /tmp/ccFR2TxI.o: In function `primary()': main.*****p:(.text+0x106): undefined reference to `get_token()' main.*****p:(.text+0x12c): undefined reference to `get_token()' collect2: error: ld returned 1 exit status --- >p203a example code https://rentry.org/PPP2_p203a https://coliru.stacked-crooked.com/a/a51235c6a0466ffb

>"To run these calculator functions, we need to implement get_token() and provide a main()." >"The main() is trivial: we just keep calling expression() and printing out its result:" >"Unsurprisingly, this first version of the calculator doesn’t work quite as we expected." >"So we shrug and ask, “Why not?” or rather, “So, why does it work the way it does?” and “What does it do?”" --- >p203b command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_06/main_p203b.*****p && ./a.out Bad token --- >p203b example code https://rentry.org/PPP2_p203b https://coliru.stacked-crooked.com/a/7ed96546edbce5d9

>>21666 >"When the Token returned by get_token() is not a + or a – we just return. We don’t use that token and we don’t store it anywhere for any other function to use later." >"That’s not smart. Throwing away input without even determining what it is can’t be a good idea." >"A quick look shows that term() has exactly the same problem. That explains why our calculator ate two tokens for each that it used. Let us modify expression() so that it doesn’t “eat” tokens. In addition, we must make the same change to term()" >"Where would we put that next token (t) when the program doesn’t need it?" >"What we want is an input stream that deals with tokens and that you can put an already read token back into. [This is our new user-defined type 'Token_stream'.]" --- >p206 command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_06/main_p206.*****p && ./a.out Bad token --- >p206 example code https://rentry.org/PPP2_p206 https://coliru.stacked-crooked.com/a/38205c2eab3a413d

>"We still have a token-look-ahead problem. However, this time the problem is not that our code “eats” characters, but that it doesn’t get any output for an expression until we enter the following expression." >"The result of an expression isn’t printed immediately; the output is postponed until the program has seen the first token of the next expression. Unfortunately, the program doesn’t see that token until we hit Return after the next expression." >"How can we fix this? One obvious solution is to require a “print command.” [;]" >"And while we are at it, let’s add an “exit command” to allow for graceful exit. [q]" --- >p209 command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_06/main_p209.*****p && ./a.out Bad token --- >p209 example code https://rentry.org/PPP2_p209 https://coliru.stacked-crooked.com/a/718d593d8109280a

>"Before further improving our calculator, let us show the implementation of Token_stream. After all, nothing – nothing at all – works until we get correct input." >"What we need is something that reads characters from the standard input, cin, and presents the program with the next token when it asks for it." >"In addition, we saw that we – that is, our calculator program – often read a token too many, so that we must be able to put it back for later use." >"A C++ user-defined type often consists of two parts: the public interface (labeled public:) and the implementation details (labeled private:)." >"The idea is to separate what a user of a type needs for convenient use from the details that we need in order to implement the type, but that we’d rather not have users mess with" --- >p210 command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_06/main_p210.*****p && ./a.out /tmp/ccY9zXib.o: In function `main': main.*****p:(.text.startup+0xa): undefined reference to `Token_stream::Token_stream()' main.*****p:(.text.startup+0x14): undefined reference to `Token_stream::get()' main.*****p:(.text.startup+0x20): undefined reference to `Token_stream::putback(Token)' collect2: error: ld returned 1 exit status --- >p210 example code https://rentry.org/PPP2_p210 https://coliru.stacked-crooked.com/a/0baf473ece0f52b9

>"Now, we need to implement those three Token_stream functions." >"How do we represent a Token_stream? That is, what data do we need to store in a Token_stream for it to do its job?" >"we just need space for one Token and an indicator of whether that space is full or empty" --- >p211 command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_06/main_p211.*****p && ./a.out --- >p211 example code https://rentry.org/PPP2_p211 https://coliru.stacked-crooked.com/a/8498de946abde6ba

>"All the real work is done by get()." >"If there isn’t already a Token in Token_stream::buffer, get() must read characters from cin and compose them into Tokens" >" " --- >p212 command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_06/main_p212.*****p && ./a.out --- >p212 example code https://rentry.org/PPP2_p212 https://coliru.stacked-crooked.com/a/344d4baf5da95971

>"Now we just have to deal with numbers. That’s actually not that easy." >"We could spend hours or days to get this right, but fortunately, we don’t have to. Input streams know what C++ literals look like and how to turn them into values of type double." >"All we have to do is to figure out how to tell cin to do that for us inside get()" >"instead of doing any messy arithmetic, we just put the initial [numeric] character back into cin, and then let cin read the [entire] number [in all at once]." --- >p214 command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_06/main_p214.*****p && ./a.out --- >p214 example code https://rentry.org/PPP2_p214 https://coliru.stacked-crooked.com/a/290b4884b4a254e5

>"Sometimes, the proverb says, it’s hard to see the forest for the trees. Similarly, it is easy to lose sight of a program when looking at all its functions, classes, etc." >"So, let’s have a look at the program with its details omitted" note: within Coliru, you can collapse functions to look similar to the book's example given. >"The order of the declarations is important. You cannot use a name before it has been declared, so ts must be declared before ts.get() uses it, and error() must be declared before the parser functions because they all use it." >"There is an interesting loop in the call graph: expression() calls term() which calls primary() which calls expression()." >"We chose to declare (“forward declare”) expression()." Stay strong. That's it for chapter 6, and we're now more than halfway complete with the project. I know that was a lot to take in Anon, but we'll wrap everything up for our calculator project in the next chapter. BTW, you do want your waifu to be able to do arithmetic for you Anon, right? :^) Stay tuned! --- >p215 command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_06/main_p215.*****p && ./a.out <<< '2+2;q' = 4 primary expected --- >p215 example code https://rentry.org/PPP2_p215 https://coliru.stacked-crooked.com/a/f8eec99cc12c5093

>"When your program first starts running “reasonably,” you’re probably about halfway finished. For a large program or a program that could do harm if it misbehaved, you will be nowhere near halfway finished." >"Once the program “basically works,” the real fun begins! That’s when we have enough working code to experiment with ideas." >"In this chapter, we will guide you through the considerations a professional programmer might have trying to improve the calculator from Chapter 6." >"We would [] like a short “prompt” to indicate that the program wants input. The > character is often used as a prompt" --- >p223 command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_07/main_p223.*****p && ./a.out <<< '2+2;q' > > = 4 primary expected --- >p223 example code https://rentry.org/PPP2_p223 https://coliru.stacked-crooked.com/a/b936e2970a2a7baa

>"We added those “print” and “quit” commands rather quickly to get the calculator to work (§6.7). Now we are paying for that haste." >"If we find a semicolon, we straightaway proceed to call expression() without checking for q." >"... So, we should test for q after testing for a semicolon." >"While we were at it, we felt the need to simplify the logic a bit" --- >p228 command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_07/main_p228.*****p && ./a.out <<< '2+2;q' > = 4 >  --- >p228 example code https://rentry.org/PPP2_p228 https://coliru.stacked-crooked.com/a/cfe6406e373bd3e1

>"If you tested the calculator, you found that it couldn’t handle negative numbers elegantly. That’s not acceptable." >"In this case, we basically need to modify the grammar to allow unary minus [and unary plus]. The simplest change seems to be in Primary." >"That’s so simple that it actually worked the first time." --- >p230 command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_07/main_p230.*****p && ./a.out <<< '-1/2;q' > = -0.5 >  --- >p230 example code https://rentry.org/PPP2_p230 https://coliru.stacked-crooked.com/a/116af9c2f367604b

>"When we first analyzed the ideals for a calculator, we wanted the remainder (modulo) operator: %. However, % is not defined for floating-point numbers, so we backed off." >"Now we can consider it again." >"But how should we handle operands that are not integers?" >"we can prohibit the use of % on a floating-point argument." --- >p231 command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_07/main_p231.*****p && ./a.out <<< '2%3;q' > = 2 >  --- >p231 example code https://rentry.org/PPP2_p231 https://coliru.stacked-crooked.com/a/f3171a0c49c4ec3f

>"Looking back, we find the use of '8' to indicate a Token containing a numeric value odd. It doesn’t really matter what value is used to indicate a number Token as long as the value is distinct" >"What we should have done was to introduce a symbolic name for the constant we used to represent a number" >"Introducing symbolic names [] makes the code easier to read [(and therefore less error-prone)]." --- >p232 command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_07/main_p232.*****p && ./a.out <<< '2+2;q' > = 4 > = primary expected --- >p232 example code https://rentry.org/PPP2_p232 https://coliru.stacked-crooked.com/a/b1b666352d559843

>"The functions we use should reflect the structure of our program, and the names of the functions should identify the logically separate parts of our code. Basically, our program so far is rather good in this respect [except main()]" >"Ideally, a function performs a single logical action" >"The obvious solution is to make the calculation loop into a separate function calculate()" >"This reflects the structure much more directly and is therefore easier to understand." --- >p234 command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_07/main_p234.*****p && ./a.out <<< '2+2;q' > = 4 >  --- >p234 example code https://rentry.org/PPP2_p234 https://coliru.stacked-crooked.com/a/accae5156e3f1a11

>"Code that is hard to read is where bugs can more easily hide. Using one line per case and adding a couple of comments help." >"We could of course have put each digit case on a separate line also, but that didn’t seem to buy us any clarity." >"When we clean up code, we might accidentally introduce errors. Always retest the program after cleanup. Remember: Test early and often." --- >p235 command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_07/main_p235.*****p && ./a.out <<< '2+2;q' > = 4 >  --- >p235 example code https://rentry.org/PPP2_p235 https://coliru.stacked-crooked.com/a/36fb42a733fbc064

>"Good comments are an important part of writing code." >"When you go back to the code to clean it up is an excellent time to look at each part of the program to see if the comments you originally wrote are [still valid]" >"Comments are for things that code expresses poorly. An example is intent: code says what it does, not what it was intended to do (§5.9.1)." >"[Remember] that the comments are not the code. [The code already says exactly what it does; comments are for the intent behind that code.]" --- >p237 command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_07/main_p237.*****p && ./a.out <<< '2+2;q' > = 4 >  --- >p237 example code https://rentry.org/PPP2_p237 https://coliru.stacked-crooked.com/a/4cec91091f0944de

>"Why do we exit when we find an error? That seemed simple and obvious at the time, but why? Couldn’t we just write an error message and carry on? After all, we often make little typing errors and such an error doesn’t mean that we have decided not to do a calculation." >"So let’s try to recover from an error." >"That basically means that we have to catch exceptions and continue after we have cleaned up any messes that were left behind." >"If we want to recover from errors, calculate() must catch exceptions and try to clean up the mess before trying to evaluate the next expression" --- >p239 command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_07/main_p239.*****p && ./a.out <<< '2+2;q' > = 4 >  --- >p239 example code https://rentry.org/PPP2_p239 https://coliru.stacked-crooked.com/a/a9e5ec6134c06003

>>21693 >"Unfortunately, that [didn't] work all that well." >"We could try more elaborate trys and catches, but basically we are heading into an even bigger mess. Errors are hard to handle, and errors during error handling are even worse than other errors." >"So, let’s try to devise some way to flush characters out of a Token_stream that couldn’t possibly throw an exception." >"Dealing with errors is always tricky. It requires much experimentation and testing because it is extremely hard to imagine what errors can occur. Trying to make a program foolproof is always a very technical activity; amateurs typically don’t care. Quality error handling is one mark of a professional." --- >p240 command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_07/main_p240.*****p && ./a.out <<< '2+2;q' > = 4 >  --- >p240 example code https://rentry.org/PPP2_p240 https://coliru.stacked-crooked.com/a/a6c816996d2c565c

>"We now have a program that works quite well; how can we improve it? The first wish list for the calculator included variables." >"Having variables gives us better ways of expressing longer calculations. Similarly, for scientific calculations, we’d like built-in named values, such as pi and e, just as we have on scientific calculators." >"Adding variables and constants is a major extension to the calculator. It will touch most parts of the code. This is the kind of extension that we should not embark on without good reason and sufficient time." >"Obviously, the key to both variables and built-in constants is for the calculator program to keep (name,value) pairs so that we can access the value given the name." >"General rules tend to keep code simple, whereas special cases tend to lead to complications." >"This mechanism for keeping track of Variables is what is often called a symbol table and could be radically simplified by the use of a standard library map; see §21.6.1." --- >p242 command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic main.*****p && ./a.out <<< 'let foo = 242;q' > = 242 >  --- >p242 example code https://rentry.org/PPP2_p242 https://coliru.stacked-crooked.com/a/ec17961d568e4f3b

>"This is all very good, but unfortunately, it doesn’t quite work. By now, that shouldn’t come as a surprise. Our first cut never — well, hardly ever — works." >"What characters can be part of a name? Letters? Certainly. Digits? Certainly, as long as they are not the starting character." >"Instead of reading directly into the string s, we read characters and put those into s as long as they are letters or digits." --- >p247 command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_07/main_p247.*****p && ./a.out <<< 'let foo = 42; foo * 2;q' > = 42 > = 84 >  --- >p247 example code https://rentry.org/PPP2_p247 https://coliru.stacked-crooked.com/a/da5bdfe2e6bb3b8f

>"Now that we have names, we can easily predefine a few common ones. For example, if we imagine that our calculator will be used for scientific calculations, we’d want pi and e." >"Where in the code would we define those? In main() before the call of calculate() or in calculate() before the loop." >"We’ll put them in main() because those definitions really aren’t part of any calculation" Stop. You've made it to the end of the calculator project. This gives you a reasonably good grounding in the basics of how to define & parse a formal Language Grammar. This elegant programming skill will be valuable for many things in the future for you; for example, using various related-approaches in teaching your robowaifu how to understand human languages (and specifically your language ofc). Congrats Anon, you've got this by now! Now keep moving forward. :^) --- >p250 command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_07/main_p250.*****p && ./a.out <<< 'let r=2;pi*(r*r);q' > = 2 > = 12.5664 >  --- >p250 example code https://rentry.org/PPP2_p250 https://coliru.stacked-crooked.com/a/8dc95f57a1c2f609

>"Given a choice, we’d much rather talk about programming than about programming language features; that is, we consider how to express ideas as code far more interesting than the technical details of the programming language that we use to express those ideas." >"However, we don’t always have a choice. When you start programming, your programming language is a foreign language for which you need to look at “grammar and vocabulary.” This is what we will do in this chapter and the next" >"A declaration is a statement that introduces a name into a scope (§8.4)" >"- Specifying a type for what is named (e.g., a variable or a function)" >"- Optionally, specifying an initializer (e.g., an initializer value or a function body)" >tl;dr >"Before a name can be used in a C++ program, it must be declared." --- >p257 command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_08/main_p257.*****p && ./a.out main.*****p:14:1: error: 'vector' does not name a type 14 | vector<Token> v; // a vector-of-Tokens variable | ^~~~~~ main.*****p: In function 'int main()': main.*****p:18:3: error: 'cout' was not declared in this scope 18 | cout << f(i) << '\n'; | ^~~~ main.*****p:18:13: error: 'i' was not declared in this scope 18 | cout << f(i) << '\n'; | ^ main.*****p:18:11: error: 'f' was not declared in this scope 18 | cout << f(i) << '\n'; | ^ --- >p257 example code https://rentry.org/PPP2_p257 https://coliru.stacked-crooked.com/a/7624f4590c2316c5

>>21719 >"We can get cout declared by including the header std_lib_facilities.h, which contains its declaration" >"As you write real-word programs, you’ll find that most declarations are found in headers. That’s where we define interfaces to useful facilities defined “elsewhere.”" >"Why does a name have to be declared before it is used? Couldn’t we just require the language implementation to read the program (just as we do) and find the definition to see how a function must be called?" >"The C++ definition requires declaration before use" >"After all, this is already the convention for ordinary (non-program) writing: when you read a textbook, you expect the author to define terminology before using it; otherwise, you have to guess or go to the index all the time." >"The “declaration before use” rule simplifies reading for both humans and compilers." --- >p258 command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_08/main_p258.*****p && ./a.out main.*****p: In function 'double term()': main.*****p:59:8: warning: infinite recursion detected [-Winfinite-recursion] 59 | double term() { // definition | ^~~~ In function 'double expression()', inlined from 'double primary()' at main.*****p:56:20, inlined from 'double term()' at main.*****p:62:17: main.*****p:68:14: note: recursive call 68 | return term(); | ~~~~^~ 7 --- >p258 example code https://rentry.org/PPP2_p258 https://coliru.stacked-crooked.com/a/b2a3e7bd46aec401

>"The declaration of a variable or a constant specifies a name, a type, and optionally an initializer." >"Constants have the same declaration syntax as variables. They differ in having const as part of their type and requiring an initializer" >"The reason for requiring an initializer for a const is obvious: how could a const be a constant if it didn’t have a value?" --- >p262 command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_08/main_p262.*****p && ./a.out main.*****p: In function 'int main()': main.*****p:19:13: error: uninitialized 'const y' [-fpermissive] 19 | const int y; // error: no initializer | ^ main.*****p:11:15: warning: unused variable 'a' [-Wunused-variable] 11 | int a; // no initializer | ^ main.*****p:12:15: warning: unused variable 'd' [-Wunused-variable] 12 | double d = 7; // initializer using the = syntax | ^ main.*****p:16:13: warning: unused variable 'x' [-Wunused-variable] 16 | const int x = 7; // initializer using the = syntax | ^ main.*****p:17:13: warning: unused variable 'x2' [-Wunused-variable] 17 | const int x2{9}; // initializer using the {} syntax | ^~ main.*****p:19:13: warning: unused variable 'y' [-Wunused-variable] 19 | const int y; // error: no initializer | ^ --- >p262 example code https://rentry.org/PPP2_p262 https://coliru.stacked-crooked.com/a/421f76e386480d5c

>"You might have noticed that we often don’t provide an initializer for strings, vectors, etc. This is not an exception to the rule that variables must be initialized before use." >"What is going on here is that string and vector are defined so that variables of those types are initialized with a default value whenever we don’t supply one explicitly." >"The mechanism for guaranteeing default initialization is called a default constructor; see §9.7.3." --- >p263 command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_08/main_p263.*****p && ./a.out <<< 'foo bar baz' --- >p263 example code https://rentry.org/PPP2_p263 https://coliru.stacked-crooked.com/a/8538f157a073f9da

>"How do we manage our declarations and definitions? After all, they have to be consistent, and in real-world programs there can be tens of thousands of declarations; programs with hundreds of thousands of declarations are not rare." >"Typically, when we write a program, most of the definitions we use are not written by us. For example, the implementations of cout and sqrt() were written by someone else many years ago. We just use them." >"The key to managing declarations of facilities defined “elsewhere” in C++ is the header." >"Since #includes logically happen before anything else a compiler does, handling #includes is part of what is called preprocessing (§A.17)." --- >p265a command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_08/main_p265a.*****p && ./a.out --- >p265a example code https://rentry.org/PPP2_p265a https://coliru.stacked-crooked.com/a/edc5e4d1fbe477d1

>>21723 >"To ease consistency checking, we #include a header both in source files that use its declarations and in source files that provide definitions for those declarations. That way, the compiler catches errors as soon as possible." >"A header [file] will typically be included in many source files." >"That means that a header [file] should only contain declarations that can be duplicated in several files (such as function declarations, class definitions, and definitions of numeric constants)." --- >p265b command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_08/main_p265b.*****p && ./a.out main.*****p: In member function 'Token Token_stream::putback(Token)': main.*****p:25:10: error: 'class Token' has no member named 'push_back' 25 | buffer.push_back(t); // error | ^~~~~~~~~ main.*****p: In function 'int main()': main.*****p:37:16: error: 'class Token_stream' has no member named 'gett' 37 | Token t = ts.gett(); // error: no member gett | ^~~~ main.*****p:41:13: error: no matching function for call to 'Token_stream::putback()' 41 | ts.putback(); // error: argument missing | ~~~~~~~~~~^~ main.*****p:24:7: note: candidate: 'Token Token_stream::putback(Token)' 24 | Token Token_stream::putback(Token t) { | ^~~~~~~~~~~~ main.*****p:24:7: note: candidate expects 1 argument, 0 provided main.*****p:37:9: warning: unused variable 't' [-Wunused-variable] 37 | Token t = ts.gett(); // error: no member gett | ^ --- >p265b example code https://rentry.org/PPP2_p265b https://coliru.stacked-crooked.com/a/dcf6e51cfdd9ebc0

>"A scope is [simply] a region of program text. [Apart from the global scope, a scope is always demarcated by a matching-pair of braces { } .]" >"A name is [always] declared [within] a scope, and is valid (is “in scope”) from the point of its declaration until the end of the scope in which it was declared." >"The main purpose of a scope is to keep names local, so that they won’t interfere with [(clash with)] names declared elsewhere." --- >p266 command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic main.*****p && ./a.out 0 --- >p266 example code https://rentry.org/PPP2_p197 https://coliru.stacked-crooked.com/a/7e3efa22964ce666

>>21725 >"Here f()’s x is different from g()’s x. They don’t “clash” because they are not in the same scope: f()’s x is local to f and g()’s x is local to g." >"So, with the notable exception of the global scope, a scope keeps names local. For most purposes, locality is good, so keep names as local as possible." >"The larger the scope of a name is, the longer and more descriptive its name should be" --- >p267 command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_08/main_p267.*****p && ./a.out --- >p267 example code https://rentry.org/PPP2_p267 https://coliru.stacked-crooked.com/a/50dee6ccf87d0dca

>>21726 >"Note that most C++ constructs that define scopes nest" >"Nested blocks are unavoidable, but be suspicious of complicated nesting: it can easily hide errors." >"Note our consistent indentation to indicate nesting. Without consistent indentation, nested constructs become unreadable." note: using clang-format (always) solves this last issue handily. >"Hard-to-read code usually hides bugs." --- >p270 command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_08/main_p270.*****p && ./a.out main.*****p: In function 'void f1()': main.*****p:28:7: error: a function-definition is not allowed here before '{' token 28 | { | ^ main.*****p:30:8: error: expected primary-expression before '...' token 30 | }... | ^~~ --- >p270 example code https://rentry.org/PPP2_p270 https://coliru.stacked-crooked.com/a/64ccb2b5bea7ba97

>"Functions are what we use in C++ to name and represent computations and actions." >"A function declaration consists of a return type followed by the name of the function followed by a list of formal arguments in parentheses." >"Formal arguments are often called parameters." >"If you don’t want a function to take arguments, just leave out the formal arguments." --- >p272 command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_08/main_p272.*****p && ./a.out true --- >p272 example code https://rentry.org/PPP2_p272 https://coliru.stacked-crooked.com/a/528e8acf8947333b

>"We return a value from a function using a return-statement" >"A function declared to return a value must return a value." >"For historical reasons, main() is a special case." >"In a function that does not return a value, we can use return without a value to cause a return from the function." --- >p274 command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_08/main_p274.*****p && ./a.out main.*****p: In function 'double my_abs(int)': main.*****p:29:1: warning: control reaches end of non-void function [-Wreturn-type] 29 | } | ^ main.*****p: In function 'T f()': main.*****p:19:10: warning: 'v' is used uninitialized [-Wuninitialized] 19 | return v; // error: uninitialized return | ^ main.*****p:15:5: note: 'v' was declared here 15 | V v; | ^ main.*****p: In function 'int main()': main.*****p:47:5: warning: 'v' is used uninitialized [-Wuninitialized] 47 | T t(v); // error: v uninitialized when used here | ^ main.*****p:42:5: note: 'v' was declared here 42 | V v; | ^ 00 --- >p274 example code https://rentry.org/PPP2_p274 https://coliru.stacked-crooked.com/a/018e58374eca59b5

>"The simplest way of passing an argument to a function is to give the function a copy of the value you use as the argument." >"An argument of a function f() is a local variable in f() that’s initialized each time f() is called." >"Pass-by-value is pretty straightforward and it's cost is the cost of copying the value." --- >p275 command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_08/main_p275.*****p && ./a.out 1 0 8 7 --- >p275 example code https://rentry.org/PPP2_p275 https://coliru.stacked-crooked.com/a/b31d69f1870fabf5

>"Pass-by-value is simple, straightforward, and efficient when we pass small values, such as an int, a double, or a Token (§6.3.2). But what if a value is large, such as an image (often, several million bits), a large table of values (say, thousands of integers), or a long string (say, hundreds of characters)?" >"Then, copying can be costly." >"The question we must ask ourselves here is: “Why are we copying anything at all?”" --- >p276 command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_08/main_p276.*****p && ./a.out { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ..., 0 } { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } --- >p276 example code https://rentry.org/PPP2_p197 https://coliru.stacked-crooked.com/a/32a0ef31d7ae6a91

>>21731 >"As an analogy, if you were given the task to make a list of books in a library, the librarians wouldn’t ship you a copy of the library building and all its contents; they would send you the address of the library, so that you could go and look at the books [there, in-place]." >"Obviously, there has to be a way for us to pass a variable to a function without copying it. Such an “address” is called a reference" >"A const reference [also] has the useful property that we can’t accidentally modify the object passed." >"Pass-by-const-reference is a useful and popular mechanism." --- >p277 command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_08/main_p277.*****p && ./a.out { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ..., 0 } { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } --- >p277 example code https://rentry.org/PPP2_p277 https://coliru.stacked-crooked.com/a/5d90b095ddc569b7

>"But what if we did want a function to modify its arguments?" >"Sometimes, that’s a perfectly reasonable thing to wish for." >"[We can avoid copying by still using a reference, but modify the original by passing] a “plain reference” [instead (that is, a non-const ref)]" --- >p279a command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_08/main_p279a.*****p && ./a.out --- >p279a example code https://rentry.org/PPP2_p279a https://coliru.stacked-crooked.com/a/8ed6c65607b5db02

>>21733 >"A reference is a construct that allows a user to declare a new name for an object." >"References can be useful as shorthand." >"This key property of references, that a reference can be a convenient shorthand for some object, is what makes them useful as arguments." --- >p279b command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_08/main_p279b.*****p && ./a.out 1 1 8 8 --- >p279b example code https://rentry.org/PPP2_p279b https://coliru.stacked-crooked.com/a/7e1dfeb653f4794e

>>21734 >"Using references, we can write a function that swaps doubles [directly]" >"Pass-by-reference is clearly a very powerful mechanism" --- >p281a command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_08/main_p281a.*****p && ./a.out x == 1, y == 2 x == 2, y == 1 --- >p281a example code https://rentry.org/PPP2_p281a https://coliru.stacked-crooked.com/a/8c96cbfc62b22436

>"When should you use pass-by-value, pass-by-reference, and pass-by-const-reference?" >"If you want to change the value of the object passed, you must use a non-const reference: pass-by-value gives you a copy and pass-by-const-reference prevents you from changing the value of the object passed." >"If we use a reference simply to avoid copying, we use a const reference." >"Consequently, when we see a non-const-reference argument, we assume that the function changes the value of its argument; that is, when we see a pass-by-non-const-reference we assume that not only can that function modify the argument passed, but it will, so that we have to look extra carefully at the call to make sure that it does what we expect it to." --- >p281b command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_08/main_p281b.*****p && ./a.out 0 3 --- >p281b example code https://rentry.org/PPP2_p281b https://coliru.stacked-crooked.com/a/6ae9cd32080b955f

>"Passing an argument is the initialization of the function’s formal argument with the actual argument specified in the call." >"Conversions are often useful, but occasionally they give surprising results (see §3.9.2). Consequently, we have to be careful with them." >"If you really mean to truncate a double value to an int, say so explicitly" --- >p284 command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_08/main_p284.*****p && ./a.out 3.1415 --- >p284 example code https://rentry.org/PPP2_p284 https://coliru.stacked-crooked.com/a/0e11557938c98da7

>"When a function is called, the language implementation sets aside a data structure containing a copy of all its parameters and local variables." >"Such a data structure is called a function activation record, and each function has its own detailed layout of its activation record. So, each time we call a function the stack of activation records, usually just called the stack, grows by one record." >''"Conversely, when the function returns, it's [activation] record is no longer used [and gets "popped" from the stack]." >"The stack, also called the call stack, is a data structure that grows and shrinks at one end [usually top-down] according to the rule “Last in, first out.”" --- >p286 command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_08/main_p286.*****p && ./a.out K --- >p286 example code https://rentry.org/PPP2_p286 https://coliru.stacked-crooked.com/a/ac464cea6b39e2a4

>"A function represents a calculation, and sometimes we want to do a calculation at compile time." >"The reason to want a calculation to be evaluated by the compiler is usually to avoid having the same calculation done millions of times at run time." >"A constexpr function behaves just like an ordinary function until you use it where a constant is needed. Then, it is calculated at compile time provided its arguments are constant expressions [] and gives an error if they are not" --- >p290 command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_08/main_p290.*****p && ./a.out main.*****p: In function 'void user(Point)': main.*****p:24:32: error: 'p1' is not a constant expression 24 | constexpr Point p5 = scale(p1); | ^ main.*****p:26:32: error: the value of 'p2' is not usable in a constant expression 26 | constexpr Point p6 = scale(p2); // p6 == {100,8} | ^ main.*****p:18:9: note: 'p2' was not declared 'constexpr' 18 | Point p2{10, 10}; | ^~ --- >p290 example code https://rentry.org/PPP2_p290 https://coliru.stacked-crooked.com/a/e48bf1bcb9a7663b

>"The evaluation of a program — also called the execution of a program — proceeds through the statements according to the language rules." >"When this “thread of execution” reaches the definition of a variable, the variable is constructed; that is, memory is set aside for the object and the object is initialized." >"When the variable goes out of scope, the variable is destroyed; that is, the object it refers to is in principle removed and the compiler can use its memory for something else." >"Global variables are initialized before the first statement of main() is executed. They “live” until the program terminates, and then they are destroyed." --- >p291 command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_08/main_p291.*****p && ./a.out --- >p291 example code https://rentry.org/PPP2_p291 https://coliru.stacked-crooked.com/a/140c87b4b30681e9

>"if you change the value of a variable in an expression, don’t read or write it twice in that same expression." >"Unfortunately, not all compilers warn if you write such bad code; it’s bad because you can’t rely on the results being the same if you move your code to another computer, use a different compiler, or use a different optimizer setting." >"Note in particular that = (assignment) is considered just another operator in an expression, so there is no guarantee that the left-hand side of an assignment is evaluated before the right-hand side." >"That’s why v[++i] = i is undefined." --- >p292 command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_08/main_p292.*****p && ./a.out main.*****p: In function 'int main()': main.*****p:19:12: warning: operation on 'i' may be undefined [-Wsequence-point] 19 | v[i] = ++i; // don't: undefined order of evaluation | ^~~ main.*****p:20:5: warning: operation on 'i' may be undefined [-Wsequence-point] 20 | v[++i] = i; // don't: undefined order of evaluation | ^~~ main.*****p:20:5: warning: operation on 'i' may be undefined [-Wsequence-point] main.*****p:21:12: warning: operation on 'i' may be undefined [-Wsequence-point] 21 | int x = ++i + ++i; // don't: undefined order of evaluation | ^~~ main.*****p:22:11: warning: operation on 'i' may be undefined [-Wsequence-point] 22 | cout << ++i << ' ' << i << '\n'; // don't: undefined order of evaluation | ^~~ main.*****p:22:11: warning: operation on 'i' may be undefined [-Wsequence-point] main.*****p:23:10: warning: operation on 'i' may be undefined [-Wsequence-point] 23 | f(++i, ++i); // don't: undefined order of evaluation | ^~~ main.*****p:23:10: warning: operation on 'i' may be undefined [-Wsequence-point] 9 9 11 11 16 --- >p292 example code https://rentry.org/PPP2_p292 https://coliru.stacked-crooked.com/a/1e0e7f3fce17484d

>"Global variables (and namespace variables; see §8.7) in a single translation unit are initialized in the order in which they appear." >"Using a global variable in anything but the most limited circumstances is usually not a good idea." >"Avoid such code, and be very suspicious when you see global variables with nontrivial initializers; consider any initializer that isn’t a constant expression complicated [(i.e., nontrivial)]." --- >p293 command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_08/main_p293.*****p && ./a.out 197019701970 --- >p293 example code https://rentry.org/PPP2_p293 https://coliru.stacked-crooked.com/a/f03f85f353083584

>"The language mechanism for [] grouping of declarations is a namespace." >"[When you name something foo, bar, etc.,] most likely somebody else in the world has used those names; but now that doesn’t matter." >"A name composed of a namespace name (or a class name) and a member name combined by :: is called a fully qualified name." --- >p295 command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_08/main_p295.*****p && ./a.out --- >p295 example code https://rentry.org/PPP2_p295 https://coliru.stacked-crooked.com/a/6c0e66061b7bf826

>"Writing fully qualified names [each and every time] can be tedious." --- >p296a command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_08/main_p296a.*****p && ./a.out Please enter your first name Hello, --- >p296a example code https://rentry.org/PPP2_p296a https://coliru.stacked-crooked.com/a/70e64a3c59f0e350

>>21744 >"Having seen the standard library string and cout thousands of times, we don’t really want to have to refer to them by their “proper” fully qualified names std::string and std::cout all the time." >"A solution is to say that “by string, I mean std::string,” “by cout, I mean std::cout,” etc." >"That construct is called a using declaration" --- >p296b command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_08/main_p296b.*****p && ./a.out Please enter your first name Hello, --- >p296b example code https://rentry.org/PPP2_p296b https://coliru.stacked-crooked.com/a/3fa4fe2b1b6b52f7

>>21745 >"Sometimes, we prefer an even stronger “shorthand” for the use of names from a namespace: “If you don’t find a declaration for a name in this scope, look in std.”" >"The way to say that is to use a using directive" --- >p296c command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_08/main_p296c.*****p && ./a.out Please enter your first name Hello, --- >p296c example code https://rentry.org/PPP2_p296c https://coliru.stacked-crooked.com/a/4d60c9e0825dd407

>>21746 >"It is usually a good idea to avoid using directives for any namespace except for a namespace, such as std, that’s extremely well known in an application area." >"The problem with overuse of using directives [as opposed to using declarations, which are good] is that you lose track of which names come from where, so that you again start to get name clashes." >"However, to simplify our initial code we did place a using directive for std in std_lib_facilities.h." Stop You are done with this chapter, and congratulations. There were a lot of technicalities involved here, and you owe yourself a reward Anon! :^) --- >p297 command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic main.*****p && ./a.out Please enter your first name Hello, --- >p297 example code https://rentry.org/PPP2_p297 https://coliru.stacked-crooked.com/a/e92805f64eba0313

>"A class is a user-defined type. It is composed of built-in types, other user-defined types, and functions. The parts used to define the class are called members. A class has zero or more members." >"Members can be of various types. Most are either data members, which define the representation of an object of the class, or function members, which provide operations on such objects." >"We access members using the object.member notation." --- >p305 command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_09/main_p305.*****p && ./a.out --- >p305 example code https://rentry.org/PPP2_p305 https://coliru.stacked-crooked.com/a/ee9a126b211da8bc

>"Usually, we think of a class as having an interface plus an implementation. The interface is the part of the class’s declaration that its users access directly." >"The implementation is that part of the class’s declaration that its users access only indirectly through the interface." >"The public interface is identified by the label public: and the implementation by the label private:." --- >p306 command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_09/main_p306.*****p && ./a.out --- >p306 example code https://rentry.org/PPP2_p306 https://coliru.stacked-crooked.com/a/9fcceec1b329b531

>>21781 >"A user cannot directly refer to a private member. Instead, we have to go through a public function that can use it." >"We use private and public to represent the important distinction between an interface (the user’s view of the class) and implementation details (the implementer’s view of the class)." >"for something that’s just data, this distinction doesn’t make sense. So, there is a useful simplified notation for a class that has no private implementation details. A struct is a class where members are public by default" --- >p307 command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_09/main_p307.*****p && ./a.out --- >p307 example code https://rentry.org/PPP2_p307 https://coliru.stacked-crooked.com/a/2da06b285f2dbb11

>"Let’s illustrate the language facilities supporting classes and the basic techniques for using them by showing how — and why — we might evolve a simple data structure into a class with private implementation details and supporting operations." >"We use the apparently trivial problem of how to represent a date (such as August 14, 1954) in a program." >"How would we represent a date?" >"A Date object, such as today, will simply be three ints. There is no “magic” relying on hidden data structures anywhere related to a Date" >"The snag is that nothing is really convenient. Just about anything that we want to do with a Date has to be written in terms of reads and writes of those members. This is tedious and error-prone. Did you spot the error? Everything that’s tedious is error-prone!" >"What we do then is to provide some helper functions to do the most common operations for us." --- >p308 command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_09/main_p308.*****p && ./a.out 2000200011 200028 --- >p308 example code https://rentry.org/PPP2_p308 https://coliru.stacked-crooked.com/a/e18fee457c284d39

>"Whenever we define a type, we want some operations for it. Exactly how many operations we want and of which kind will vary." >"Exactly how we provide them (as functions, member functions, or operators) will also vary, but whenever we decide to provide a type, we ask ourselves, “Which operations would we like for this type?”" >"We provided an initialization function for Dates, one that provided an important check on the validity of Dates. However, checking functions are of little use if we fail to use them." >"This [] leads to a demand for an initialization function that can’t be forgotten and for operations that are less likely to be overlooked." --- >p310 command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_09/main_p310.*****p && ./a.out 012242005 --- >p310 example code https://rentry.org/PPP2_p310 https://coliru.stacked-crooked.com/a/987972682f570377

>"A member function with the same name as its class is special. It is called a constructor and will be used for initialization (“construction”) of objects of the class." >"It is an error — caught by the compiler — to forget to initialize an object of a class that has a constructor that requires an argument, and there is a special convenient syntax for doing such initialization:" >"a { } list immediately after the name of the variable [is] the most common style of initialization of variables of a class that has a constructor requiring arguments." --- >p311 command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_09/main_p311.*****p && ./a.out --- >p311 example code https://rentry.org/PPP2_p311 https://coliru.stacked-crooked.com/a/07ca2db23401faf8

>"We still have a problem: What if someone forgets to use the member function add_day()? What if someone decides to change the month directly?" >"As long as we leave the representation of Date accessible to everybody, somebody will — by accident or design — mess it up; that is, someone will do something that produces an invalid value." >"Such invalid objects are time bombs; it is just a matter of time before someone innocently uses the invalid value and gets a run-time error or — usually worse — produces a bad result." --- >p312 command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_09/main_p312.*****p && ./a.out --- >p312 example code https://rentry.org/PPP2_p312 https://coliru.stacked-crooked.com/a/3e643015671d6f2d

>>21786 >"Such concerns lead us to conclude that the representation of Date should be inaccessible to users except through the public member functions that we supply." >"We try to design our types so that values are guaranteed to be valid; that is, we hide the representation, provide a constructor that creates only valid objects, and design all member functions to expect valid values and leave only valid values behind when they return." >"A rule for what constitutes a valid value is called an invariant. The invariant for Date (“A Date must represent a day in the past, present, or future”) is unusually hard to state precisely: remember leap years, the Gregorian calendar, time zones, etc." >"If we can’t think of a good invariant, we are probably dealing with plain data. If so, use a struct." --- >p313 command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_09/main_p313.*****p && ./a.out 12 --- >p313 example code https://rentry.org/PPP2_p313 https://coliru.stacked-crooked.com/a/9a87e8754194c3cc

>"here is a subset of the Date class reorganized to suit the common style of providing the public interface first" >"People put the public interface first because the interface is what most people are interested in. In principle, a user need not look at the implementation details." >"In reality, we are typically curious and have a quick look to see if the implementation looks reasonable and if the implementer used some technique that we could learn from." >"The compiler doesn’t care about the order of class function and data members; it takes the declarations in any order you care to present them." --- >p314 command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic main.*****p && ./a.out main.*****p: In function 'int month()': main.*****p:35:10: error: 'm' was not declared in this scope 35 | return m; // not the member function, can’t access m | ^ --- >p314 example code https://rentry.org/PPP2_p314 https://coliru.stacked-crooked.com/a/4972efb729362694

>>21788 >"The :y{yy}, m{mm}, d{dd} notation is how we initialize members. It is called a (member) initializer list." >"[We could default initialize members, but that opens up] the possibility of accidentally using a member before it was initialized." >"We can also define member functions right in the class definition" --- >p315 command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_09/main_p315.*****p && ./a.out 2004829 --- >p315 example code https://rentry.org/PPP2_p315/png https://coliru.stacked-crooked.com/a/3c91ba51c2f1249c

>"How does Date::month() know to return the value of d1.m in the first call and d2.m in the second?" >"How does Date::month() know for which object it was called?" >"A class member function, such as Date::month(), has an implicit argument which it uses to identify the object for which it is called." --- >p317a command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_09/main_p317a.*****p && ./a.out 3 2 --- >p317a example code https://rentry.org/PPP2_p317a https://coliru.stacked-crooked.com/a/bb2ead549d27084a

>"What do we do when we find an invalid date? Where in the code do we look for invalid dates?" >"From §5.6, we know that the answer to the first question is “Throw an exception,” and the obvious place to look is where we first construct a Date." >"If we don’t create invalid Dates and also write our member functions correctly, we will never have a Date with an invalid value." --- >p317b command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_09/main_p317b.*****p && ./a.out {2004,8,29} error: invalid date --- >p317b example code https://rentry.org/PPP2_p317b https://coliru.stacked-crooked.com/a/cf3ffc0450ef23f5

>"An enum (an enumeration) is a very simple user-defined type, specifying its set of values (its enumerators) as symbolic constants. The “body” of an enumeration is simply a list of its enumerators." >"The class in enum class means that the enumerators are in the scope of the enumeration. That is, to refer to jan, we have to say Month::jan." >"If we don’t initialize the first enumerator, the count starts with 0." --- >p318 command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_09/main_p318.*****p && ./a.out error: bad month --- >p318 example code https://rentry.org/PPP2_p318 https://coliru.stacked-crooked.com/a/58d359c9b9b58e59

>"In addition to the enum classes, also known as scoped enumerations, there are “plain” enumerations that differ from scoped enumerations by implicitly “exporting” their enumerators to the scope of the enumeration and allowing implicit conversions to int." >"Obviously, “plain” enums are less strict than enum classes. Their enumerators can “pollute” the scope in which their enumerator is defined." >"Prefer the simpler and safer enum classes to “plain” enums, but expect to find “plain” enums in older code" --- >p320 command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_09/main_p320.*****p && ./a.out error: bad month --- >p320 example code https://rentry.org/PPP2_p320 https://coliru.stacked-crooked.com/a/defdf2fb1b8fcfdd

>"You can define almost all C++ operators for class or enumeration operands." >"That’s often called operator overloading. We use it when we want to provide conventional notation for a type we design." >"You can define just about any operator provided by C++ for your own types, but only existing operators, such as +, –, *, /, %, [ ], ( ), ^, !, &, <, <=, >, and >=." --- >p321 command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_09/main_p321.*****p && ./a.out January --- >p321 example code https://rentry.org/PPP2_p321 https://coliru.stacked-crooked.com/a/9d1fdb263b5790f6

>"When we defined the constructor for Date in §9.4.3, we used three ints as the arguments. That caused some problems" >"When we use a Month type, the compiler will catch us if we swap month and day, and using an enumeration as the Month type also gives us symbolic names to use." >"When we have a choice, we catch errors at compile time rather than at run time. We prefer for the compiler to find the error rather than for us to try to figure out exactly where in the code a problem occurred." --- >p324 command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_09/main_p324.*****p && ./a.out --- >p324 example code https://rentry.org/PPP2_p324 https://coliru.stacked-crooked.com/a/ec9638833510d62e

>"Also, errors caught at compile time don’t require checking code to be written and executed." >"When we program, we always have to ask ourselves what is good enough for a given application. We usually don’t have the luxury of being able to search “forever” for the perfect solution after we have already found one that is good enough." >"Search further, and we might even come up with something that’s so elaborate that it is worse than the simple early solution. This is one meaning of the saying “The best is the enemy of the good” (Voltaire)." --- >p325 command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_09/main_p325.*****p && ./a.out error: Invalid year --- >p325 example code https://rentry.org/PPP2_p325 https://coliru.stacked-crooked.com/a/3aaafcec8caba289

>"Can we copy our [user-defined] objects? And if so, how do we copy them?" >"For Date or Month, the answer is that we obviously want to copy objects of that type and that the meaning of copy is trivial: just copy all of the members." >"What if we don’t want the default meaning of copying? We can either define our own (see §18.3) or delete the copy constructor and copy assignment (see §14.2.4)." --- >p326 command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_09/main_p326.*****p && ./a.out {1978,12,24} --- >p326 example code https://rentry.org/PPP2_p326 https://coliru.stacked-crooked.com/a/9a59904baf0c8397

>"Uninitialized variables can be a serious source of errors. To counter that problem, we have the notion of a constructor to guarantee that every object of a class is initialized." >"For example, we declared the constructor Date::Date(int,Month,int) to ensure that every Date is properly initialized. In the case of Date, that means that the programmer must supply three arguments of the right types." >"Many classes have a good notion of a default value; that is, there is an obvious answer to the question “What value should it have if I didn’t give it an initializer?”" --- >p327 command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_09/main_p327.*****p && ./a.out --- >p327 example code https://rentry.org/PPP2_p327 https://coliru.stacked-crooked.com/a/ff15abfd80456558

>>21798 >"Using a default constructor is not just a matter of looks. Imagine that we could have an uninitialized string or vector." >"If the values of s and v were genuinely undefined, s and v would have no notion of how many elements they contained or (using the common implementation techniques; see §17.5) where those elements were supposed to be stored." >"For many types, it is better to define a constructor that gives meaning to the creation of an object without an explicit initializer. Such a constructor takes no arguments and is called a default constructor." --- >p328 command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_09/main_p328.*****p && ./a.out --- >p328 example code https://rentry.org/PPP2_p328 https://coliru.stacked-crooked.com/a/4d85e414c11129dd

>>21799 >"Instead of placing the default values for members in the constructor, we could place them on the members themselves, That way, the default values are available to every constructor." >"the specified initializers (Month::jan and 1) are implicitly used. An initializer for a class member specified as part of the member declaration is called an in-class initializer." >"If we didn’t like to build the default value right into the constructor code, we could use a constant (or a variable). To avoid a global variable and its associated initialization problems, we use the technique from §8.6.2" >"Note that the default constructor does not need to check its value; the constructor for default_date() already did that." --- >p329 command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_09/main_p329.*****p && ./a.out {2001,1,1} {2001,1,1} {2001,1,1} {2001,1,1} {2001,1,1} {2001,1,1} {2001,1,1} {2001,1,1} {2001,1,1} {2001,1,1} --- >p329 example code https://rentry.org/PPP2_p329 https://coliru.stacked-crooked.com/a/f37c081c07c1f615

>"Some variables are meant to be changed — that’s why we call them “variables” — but some are not; that is, we have “variables” representing immutable values. Those, we typically call constants or just consts." >"[we can classify] operations on a class as modifying and nonmodifying (that is, const or not)." >"That’s a pretty fundamental distinction that helps us understand a class, but it also has a very practical importance: operations that do not modify the object can be invoked for const objects." >"What the compiler provides for the class implementer is primarily protection against accident, which is particularly useful for more complex code." --- >p330 command line + possible output: g++ -std=c++20 -O2 -Wall -pedantic ./ch_09/main_p330.*****p && ./a.out 20 — 21 --- >p330 example code https://rentry.org/PPP2_p330 https://coliru.stacked-crooked.com/a/28aae79240d5304d