Programming Principles and Practice Using C++
Programming Principles and Practice Using C++
Product Description
An Introduction to Programming by the Inventor of C++
Preparation for Programming in the Real World
The book assumes that you aim eventually to write non-trivial programs, whether for work in software development or in some other technical field.
Focus on Fundamental Concepts and Techniques
The book explains fundamental concepts and techniques in greater depth than traditional introductions. This approach will give you a solid foundation for writing useful, correct, maintainable, and efficient code.
Programming with Today’s C++
The book is an introduction to programming in general, including object-oriented programming and generic programming. It is also a solid introduction to the C++ programming language, one of the most widely used languages for real-world software. The book presents modern C++ programming techniques from the start, introducing the C++ standard library to simplify programming tasks.
For Beginners–And Anyone Who Wants to Learn Something New
The book is primarily designed for people who have never programmed before, and it has been tested with more than 1,000 first-year university students. However, practitioners and advanced students will gain new insight and guidance by seeing how a recognized master approaches the elements of his art.
Provides a Broad View
The first half of the book covers a wide range of essential concepts, design and programming techniques, language features, and libraries. Those will enable you to write programs involving input, output, computation, and simple graphics. The second half explores more specialized topics, such as text processing and testing, and provides abundant reference material. Source code and support supplements are available from the author’s website.
About the Author
Bjarne Stroustrup is the designer and original implementer of C++, the author of The C++ Programming Language, The Annotated C++ Reference Manual, and The Design and Evolution of C++, and the consulting editor of Addison-Wesley's C++ In-Depth Series. Having previously worked at Bell Labs and AT&T Labs-Research, he currently is the College of Engineering Chair in Computer Science Professor at Texas A&M University. The recipient of numerous honors, including the Dr. Dobb's Excellence in Programming Award (2008), Dr. Stroustrup is a member of the National Academy of Engineering, an AT&T Fellow, an AT&T Bell Laboratories Fellow, an IEEE Fellow, and an ACM Fellow. His research interests include distributed systems, simulation, design, programming techniques, software development tools, and programming languages, and he remains actively involved in the ANSI/ISO standardization of C++. Dr. Stroustrup holds an advanced degree from the University of Aarhus in his native Denmark and a Ph.D. in Computer Science from Cambridge University, England.
Table of Contents
Preface xxiii
Chapter 0: Notes to the Reader 1
0.1 The structure of this book 2
0.2 A philosophy of teaching and learning 6
0.3 Programming and computer science 12
0.4 Creativity and problem solving 12
0.5 Request for feedback 12
0.6 References 13
0.7 Biographies 14
Chapter 1: Computers, People, and Programming 17
1.1 Introduction 18
1.2 Software 19
1.3 People 21
1.4 Computer science 24
1.5 Computers are everywhere 25
1.6 Ideals for programmers 34
Part I: The Basics 41
Chapter 2: Hello,World! 43
2.1 Programs 44
2.2 The classic first program 45
2.3 Compilation 47
2.4 Linking 51
2.5 Programming environments 52
Chapter 3: Objects, Types, and Values 59
3.1 Input 60
3.2 Variables 62
3.3 Input and type 64
3.4 Operations and operators 66
3.5 Assignment and initialization 69
3.6 Composite assignment operators 73
3.7 Names 74
3.8 Types and objects 77
3.9 Type safety 78
Chapter 4: Computation 89
4.1 Computation 90
4.2 Objectives and tools 92
4.3 Expressions 94
4.4 Statements 99
4.5 Functions 112
4.6 Vector 116
4.7 Language features 123
Chapter 5: Errors 131
5.1 Introduction 132
5.2 Sources of errors 134
5.3 Compile-time errors 134
5.4 Link-time errors 137
5.5 Run-timeerrors 138
5.6 Exceptions 144
5.7 Logic errors 152
5.8 Estimation 155
5.9 Debugging 156
5.10 Pre- and post-conditions 161
5.11 Testing 164
Chapter 6: Writing a Program 171
6.1 A problem 172
6.2 Thinking about the problem 173
6.3 Back to the calculator! 176
6.4 Grammars 186
6.5 Turning a grammar into code 193
6.6 Trying the first version 201
6.7 Trying the second version 206
6.8 Token streams 207
6.9 Program structure 213
Chapter 7: Completing a Program 219
7.1 Introduction 220
7.2 Input and output 220
7.3 Error handling 222
7.4 Negative numbers 227
7.5 Remainder: % 228
7.6 Cleaning up the code 231
7.7 Recovering from errors 238
7.8 Variables 241
Chapter 8: Technicalities: Functions, etc. 253
8.1 Technicalities 254
8.2 Declarations and definitions 255
8.3 Header files 261
8.4 Scope 264
8.5 Function call and return 269
8.6 Order of evaluation 287
8.7 Namespaces 290
Chapter 9: Technicalities: Classes, etc. 299
9.1 User-defined types 300
9.2 Classes and members 301
9.3 Interface and implementation 302
9.4 Evolving a class 304
9.5 Enumerations 314
9.6 Operator overloading 316
9.7 Class interfaces 318
9.8 The Date class 328
Part II: Input and Output 337
Chapter 10: Input and Output Streams 339
10.1 Input and output 340
10.2 The I/O stream model 341
10.3 Files 343
10.4 Opening a file 344
10.5 Reading and writing a file 346
10.6 I/O error handling 348
10.7 Reading a single value 352
10.8 User-defined output operators 357
10.9 User-defined input operators 359
10.10 A standard input loop 359
10.11 Reading a structured file 361
Chapter 11: Customizing Input and Output 375
11.1 Regularity and irregularity 376
11.2 Output formatting 376
11.3 File opening and positioning 384
11.4 String streams 390
11.5 Line-oriented input 391
11.6 Character classification 392
11.7 Using nonstandard separators 394
11.8 And there is so much more 401
Chapter 12: A Display Model 407
12.1 Why graphics? 408
12.2 A display model 409
12.3 A first example 410
12.4 Using a GUI library 414
12.5 Coordinates 415
12.6 Shapes 416
12.7 Using Shape primitives 417
12.8 Getting this to run 431
Chapter 13: Graphics Classes 437
13.1 Overview of graphics classes 438
13.2 Point and Line 440
13.3 Lines 443
13.4 Color 445
13.5 Line_style 448
13.6 Open_polyline 450
13.7 Closed_polyline 451
13.8 Polygon 453
13.9 Rectangle 455
13.10 Managing unnamed objects 459
13.11 Text 462
13.12 Circle 464
13.13 Ellipse 466
13.14 Marked_polyline 468
13.15 Marks 469
13.16 Mark 470
13.17 Images 472
Chapter 14: Graphics Class Design 479
14.1 Design principles 480
14.2 Shape 485
14.3 Base and derived classes 496
14.4 Benefits of object-oriented programming 504
Chapter 15: Graphing Functions and Data 509
15.1 Introduction 510
15.2 Graphing simple functions 510
15.3 Function 514
15.4 Axis 518
15.5 Approximation 521
15.6 Graphing data 526
Chapter 16: Graphical User Interfaces 539
16.1 User interface alternatives 540
16.2 The “Next” button 541
16.3 A simple window 542
16.4 Button and other Widgets 548
16.5 An example 552
16.6 Control inversion 556
16.7 Adding a menu 557
16.8 Debugging GUI code 562
Part III: Data and Algorithms 567
Chapter 17: Vector and Free Store 569
17.1 Introduction 570
17.2 vector basics 572
17.3 Memory, addresses, and pointers 574
17.4 Free store and pointers 577
17.5 Destructors 586
17.6 Access to elements 590
17.7 Pointers to class objects 591
17.8 Messing with types: void* and casts 593
17.9 Pointers and references 595
17.10 The this pointer 603
Chapter 18: Vectors and Arrays 611
18.1 Introduction 612
18.2 Copying 613
18.3 Essential operations 620
18.4 Access to vector elements 625
18.5 Arrays 627
18.6 Examples: palindrome 637
Chapter 19: Vector, Templates, and Exceptions 645
19.1 The problems 646
19.2 Changing size 649
19.3 Templates 656
19.4 Range checking and exceptions 668
19.5 Resources and exceptions 672
Chapter 20: Containers and Iterators 685
20.1 Storing and processing data 686
20.2 STL ideals 690
20.3 Sequences and iterators 694
20.4 Linked lists 698
20.5 Generalizing vector yet again 703
20.6 An example: a simple text editor 704
20.7 vector, list, and string 711
20.8 Adapting our vector to the STL 715
20.9 Adapting built-in arrays to the STL 718
20.10 Container overview 719
Chapter 21: Algorithms and Maps 727
21.1 Standard library algorithms 728
21.2 The simplest algorithm: find() 729
21.3 The general search: find_if() 732
21.4 Function objects 734
21.5 Numerical algorithms 738
21.6 Associative containers 744
21.7 Copying 757
21.8 Sorting and searching 762
Part IV: Broadening the View 769
Chapter 22: Ideals and History 771
22.1 History, ideals, and professionalism 772
22.2 Programming language history overview 783
Chapter 23: Text Manipulation 813
23.1 Text 814
23.2 Strings 814
23.3 I/O streams 819
23.4 Maps 820
23.5 A problem 828
23.6 The idea of regular expressions 830
23.7 Searching with regular expressions 833
23.8 Regular expression syntax 836
23.9 Matching with regular expressions 844
23.10 References 849
Chapter 24: Numerics 853
24.1 Introduction 854
24.2 Size, precision, and overflow 854
24.3 Arrays 859
24.4 C-style multidimensional arrays 859
24.5 The Matrix library 861
24.6 An example: solving linear equations 872
24.7 Random numbers 877
24.8 The standard mathematical functions 879
24.9 Complex numbers 880
24.10 References 882
Chapter 25: Embedded Systems Programming 887
25.1 Embedded systems 888
25.2 Basic concepts 891
25.3 Memory management 897
25.4 Addresses, pointers, and arrays 905
25.5 Bits, bytes, and words 916
25.6 Coding standards 935
Chapter 26: Testing 949
26.1 What we want 950
26.2 Proofs 952
26.3 Testing 952
26.4 Design for testing 978
26.5 Debugging 979
26.6 Performance 979
26.7 References 983
Chapter 27: The C Programming Language 987
27.1 C and C++: siblings 988
27.2 Functions 994
27.3 Minor language differences 1002
27.4 Free store 1009
27.5 C-style strings 1011
27.6 Input/output: stdio 1016
27.7 Constants and macros 1020
27.8 Macros 1021
27.9 An example: intrusive containers 1025
Part V: Appendices 1035
Appendix A: Language Summary 1037
A.1 General 1038
A.2 Literals 1041
A.3 Identifiers 1045
A.4 Scope, storage class, and lifetime 1046
A.5 Expressions 1049
A.6 Statements 1059
A.7 Declarations 1061
A.8 Built-in types 1062
A.9 Functions 1066
A.10 User-defined types 1069
A.11 Enumerations 1070
A.12 Classes 1071
A.13 Templates 1083
A.14 Exceptions 1086
A.15 Namespaces 1088
A.16 Aliases 1089
A.17 Preprocessor directives 1090
Appendix B: Standard Library Summary 1093
B.1 Overview 1094
B.3 Iterators 1100
B.4 Containers 1105
B.5 Algorithms 1112
B.6 STL utilities 1121
B.7 I/O streams 1124
B.8 String manipulation 1131
B.9 Numerics 1135
B.10 C standard library functions 1140
B.11 Other libraries 1150
Appendix C: Getting Started with Visual Studio 1151
C.1 Getting a program to run 1152
C.2 Installing Visual Studio 1152
C.3 Creating and running a program 1153
C.4 Later 1155
Appendix D: Installing FLTK 1157
D.1 Introduction 1158
D.2 Downloading FLTK 1158
D.3 Installing FLTK 1159
D.4 Using FLTK in Visual Studio 1159
D.5 Testing if it all worked 1160
Appendix E: GUI Implementation 1161
E.1 Callback implementation 1162
E.2 Widget implementation 1163
E.3 Window implementation 1164
E.4 Vector_ref 1166
E.5 An example: manipulating Widgets 1167
Glossary 1171
Bibliography 1177
Index 1181
Forewords & Introductions
“Damn the torpedoes! Full speed ahead.”
—Admiral Farragut
Please read Chapter 0 (“Notes to the Reader”) for an explanation of my teaching philosophy, general approach, etc. Please try to convey those ideas to your students along the way.
# Paperback: 1272 pages
# Publisher: Addison-Wesley Professional; 1 edition (December 25, 2008)
# Language: English
# ISBN-10: 0321543726
# ISBN-13: 978-0321543721
Code:
http://uploading.com/files/T387LGD4/0321543726_Principles_and_Practice_Using...rar.html
