SINGAPORE
Law
欢迎光临 | 登入
搜索
进阶搜索
C++ Primer Plus (Developer's Library) (6TH): Prata, Stephen: BOOKS KINOKUNIYA
书籍资料
C++ Primer Plus (Developer's Library) (6TH)
C++ Primer Plus (Developer's Library) (6TH)
作者: Prata, Stephen
出版日期 : 2011/10
Binding : Paperback
ISBN : 9780321776402

BookWeb售价 : S$ 91.49
纪伊国屋KPC会员价 : S$ 73.19

库存资料 : 目前供货中心有库存。
通常在5个工作天内递送
语言 : English
Stock Information
Store Shelf Location Click here Stock
Singapore Main Store H10-04, H10-01 Map
Liang Court Store -
Bugis Junction Store -
Important
  • While every attempt has been made to ensure stock availability, occasionally we do run out of stock at our stores.
  • Retail store and online prices may vary.
  • To confirm availability and pricing, please call the store directly.
Retail Store Contact Details and Operating Hours

书籍简介
Source: ENG
Academic Descriptors: A93603276
Place of Publication: United States
Edition: Subsequent
Continuations: Monograph Series,any number
Textual Format: Computer Applications
Academic Level: Extracurricular
Table of Contents
 
Introduction                                       1   (8)
    1 Getting Started with C++                     9   (18)
      Learning C++: What Lies Before You           10  (1)
      The Origins of C++: A Little History         10  (5)
      Portability and Standards                    15  (3)
      The Mechanics of Creating a Program          18  (7)
      Summary                                      25  (2)
    2 Setting Out to C++                           27  (38)
      C++ Initiation                               27  (14)
      C++ Statements                               41  (4)
      More C++ Statements                          45  (3)
      Functions                                    48  (13)
      Summary                                      61  (1)
      Chapter Review                               62  (1)
      Programming Exercises                        62  (3)
    3 Dealing with Data                            65  (50)
      Simple Variables                             66  (24)
      The const Qualifier                          90  (2)
      Floating-Point Numbers                       92  (5)
      C++ Arithmetic Operators                     97  (12)
      Summary                                      109 (1)
      Chapter Review                               110 (1)
      Programming Exercises                        111 (4)
    4 Compound Types                               115 (80)
      Introducing Arrays                           116 (4)
      Strings                                      120 (11)
      Introducing the string Class                 131 (9)
      Introducing Structures                       140 (9)
      Unions                                       149 (1)
      Enumerations                                 150 (3)
      Pointers and the Free Store                  153 (14)
      Pointers, Arrays, and Pointer Arithmetic     167 (17)
      Combinations of Types                        184 (2)
      Array Alternatives                           186 (4)
      Summary                                      190 (1)
      Chapter Review                               191 (1)
      Programming Exercises                        192 (3)
    5 Loops and Relational Expressions             195 (58)
      Introducing for Loops                        196 (28)
      The while Loop                               224 (7)
      The do while Loop                            231 (2)
      The Range-Based for Loop (C++11)             233 (1)
      Loops and Text Input                         234 (10)
      Nested Loops and Two-Dimensional Arrays      244 (5)
      Summary                                      249 (1)
      Chapter Review                               250 (1)
      Programming Exercises                        251 (2)
    6 Branching Statements and Logical Operators   253 (52)
      The if Statement                             254 (6)
      Logical Expressions                          260 (10)
      The cctype Library of Character Functions    270 (3)
      The?: Operator                               273 (1)
      The switch Statement                         274 (6)
      The break and continue Statements            280 (3)
      Number-Reading Loops                         283 (4)
      Simple File Input/Output                     287 (11)
      Summary                                      298 (1)
      Chapter Review                               298 (3)
      Programming Exercises                        301 (4)
    7 Functions: C++'s Programming Modules         305 (74)
      Function Review                              306 (7)
      Function Arguments and Passing by Value      313 (7)
      Functions and Arrays                         320 (17)
      Functions and Two-Dimensional Arrays         337 (2)
      Functions and C-Style Strings                339 (4)
      Functions and Structures                     343 (10)
      Functions and string Class Objects           353 (2)
      Functions and array Objects                  355 (2)
      Recursion                                    357 (4)
      Pointers to Functions                        361 (10)
      Summary                                      371 (1)
      Chapter Review                               372 (2)
      Programming Exercises                        374 (5)
    8 Adventures In Functions                      379 (68)
      C++ Inline Functions                         379 (4)
      Reference Variables                          383 (26)
      Default Arguments                            409 (3)
      Function Overloading                         412 (7)
      Function Templates                           419 (23)
      Summary                                      442 (1)
      Chapter Review                               443 (1)
      Programming Exercises                        444 (3)
    9 Memory Models and Namespaces                 447 (58)
      Separate Compilation                         447 (6)
      Storage Duration, Scope, and Linkage         453 (29)
      Namespaces                                   482 (15)
      Summary                                      497 (1)
      Chapter Review                               498 (3)
      Programming Exercises                        501 (4)
    10 Objects and Classes                         505 (58)
      Procedural and Object-Oriented Programming   506 (1)
      Abstraction and Classes                      507 (17)
      Class Constructors and Destructors           524 (15)
      Knowing Your Objects: The this Pointer       539 (7)
      An Array of Objects                          546 (3)
      Class Scope                                  549 (3)
      Abstract Data Types                          552 (5)
      Summary                                      557 (1)
      Chapter Review                               558 (1)
      Programming Exercises                        559 (4)
    11 Working with Classes                        563 (64)
      Operator Overloading                         564 (1)
      Time on Our Hands: Developing an Operator    565 (13)
      Overloading Example
      Introducing Friends                          578 (9)
      Overloaded Operators: Member Versus          587 (1)
      Nonmember Functions
      More Overloading: A Vector Class             588 (18)
      Automatic Conversions and Type Casts for     606 (15)
      Classes
      Summary                                      621 (2)
      Chapter Review                               623 (1)
      Programming Exercises                        623 (4)
    12 Classes and Dynamic Memory Allocation       627 (80)
      Dynamic Memory and Classes                   628 (19)
      The New, Improved string Class               647 (12)
      Things to Remember When Using new in         659 (3)
      Constructors
      Observations About Returning Objects         662 (3)
      Using Pointers to Objects                    665 (11)
      Reviewing Techniques                         676 (2)
      A Queue Simulation                           678 (21)
      Summary                                      699 (1)
      Chapter Review                               700 (2)
      Programming Exercises                        702 (5)
    13 Class Inheritance                           707 (78)
      Beginning with a Simple Base Class           708 (12)
      Inheritance: An Is-a Relationship            720 (2)
      Polymorphic Public Inheritance               722 (15)
      Static and Dynamic Binding                   737 (8)
      Access Control: protected                    745 (1)
      Abstract Base Classes                        746 (11)
      Inheritance and Dynamic Memory Allocation    757 (9)
      Class Design Review                          766 (12)
      Summary                                      778 (1)
      Chapter Review                               779 (1)
      Programming Exercises                        780 (5)
    14 Reusing Code in C++                         785 (92)
      Classes with Object Members                  786 (11)
      Private Inheritance                          797 (11)
      Multiple Inheritance                         808 (22)
      Class Templates                              830 (36)
      Summary                                      866 (3)
      Chapter Review                               869 (2)
      Programming Exercises                        871 (6)
    15 Friends, Exceptions, and More               877 (74)
      Friends                                      877 (12)
      Nested Classes                               889 (7)
      Exceptions                                   896 (37)
      Runtime Type Identification                  933 (10)
      Type Cast Operators                          943 (4)
      Summary                                      947 (1)
      Chapter Review                               947 (2)
      Programming Exercises                        949 (2)
    16 The string Class and the Standard           951 (110)
    Template Library
      The string Class                             952 (16)
      Smart Pointer Template Classes               968 (10)
      The Standard Template Library                978 (14)
      Generic Programming                          992 (34)
      Function Objects (A.K.A. Functors)           1026(9)
      Algorithms                                   1035(10)
      Other Libraries                              1045(9)
      Summary                                      1054(2)
      Chapter Review                               1056(1)
      Programming Exercises                        1057(4)
    17 Input, Output, and Files                    1061(92)
      An Overview of C++ Input and Output          1062(7)
      Output with cout                             1069(24)
      Input with cin                               1093(21)
      File Input and Output                        1114(28)
      Incore Formatting                            1142(3)
      Summary                                      1145(1)
      Chapter Review                               1146(2)
      Programming Exercises                        1148(5)
    18 Visiting with the New C++ Standard          1153(62)
      C++11 Features Revisited                     1153(11)
      Move Semantics and the Rvalue Reference      1164(14)
      New Class Features                           1178(6)
      Lambda Functions                             1184(7)
      Wrappers                                     1191(6)
      Variadic Templates                           1197(5)
      More C++11 Features                          1202(3)
      Language Change                              1205(2)
      What Now?                                    1207(1)
      Summary                                      1208(1)
      Chapter Review                               1209(3)
      Programming Exercises                        1212(3)
  Appendixes
      A Number Bases                               1215(6)
      B C++ Reserved Words                         1221(4)
      C The ASCII Character Set                    1225(6)
      D Operator Precedence                        1231(4)
      E Other Operators                            1235(14)
      F The string Template Class                  1249(22)
      G The Standard Template Library Methods      1271(52)
      and Functions
      H Selected Readings and Internet Resources   1323(4)
      I Converting to ISO Standard C++             1327(8)
      J Answers to Chapter Reviews                 1335(32)
Index                                              1367
 

C++ Primer Plus, Sixth Edition New C++11 Coverage C++ Primer Plus is a carefully crafted, complete tutorial on one of the most significant and widely used programming languages today. An accessible and easy-to-use self-study guide, this book is appropriate for both serious students of programming as well as developers already proficient in other languages. The sixth edition of C++ Primer Plus has been updated and expanded to cover the latest developments in C++, including a detailed look at the new C++11 standard. Author and educator Stephen Prata has created an introduction to C++ that is instructive, clear, and insightful. Fundamental programming concepts are explained along with details of the C++ language. Many short, practical examples illustrate just one or two concepts at a time, encouraging readers to master new topics by immediately putting them to use. Review questions and programming exercises at the end of each chapter help readers zero in on the most critical information and digest the most difficult concepts.In C++ Primer Plus, you'll find depth, breadth, and a variety of teaching techniques and tools to enhance your learning: * A new detailed chapter on the changes and additional capabilities introduced in the C++11 standard * Complete, integrated discussion of both basic C language and additional C++ features* Clear guidance about when and why to use a feature* Hands-on learning with concise and simple examples that develop your understanding a concept or two at a time* Hundreds of practical sample programs* Review questions and programming exercises at the end of each chapter to test your understanding* Coverage of generic C++ gives you the greatest possible flexibility* Teaches the ISO standard, including discussions of templates, the Standard Template Library, the string class, exceptions, RTTI, and namespacesTable of Contents 1: Getting Started with C++ 2: Setting Out to C++ 3: Dealing with Data 4: Compound Types 5: Loops and Relational Expressions 6: Branching Statements and Logical Operators 7: Functions: C++'s Programming Modules 8: Adventures in Functions 9: Memory Models and Namespaces 10: Objects and Classes 11: Working with Classes 12: Classes and Dynamic Memory Allocation 13: Class Inheritance 14: Reusing Code in C++ 15: Friends, Exceptions, and More 16: The string Class and the Standard Template Library 17: Input, Output, and Files 18: The New C++11 Standard A Number Bases B C++ Reserved Words C The ASCII Character Set D Operator Precedence E Other Operators F The stringTemplate Class G The Standard Template Library Methods and Functions H Selected Readings and Internet Resources I Converting to ISO Standard C++ J Answers to Chapter Reviews

Contents
C++ Primer Plus, Sixth Edition New C++11 Coverage Chapter 1Started with C++ Learning C++: What Lies Before You The Origins of C++: A Little History Portability and Standards The Mechanics of Creating a Program Chapter 2: Setting Out to C++ C++ Initiation C++ Statements More C++ Statements Functions Chapter 3: Dealing with Data Simple Variables The const Qualifier Floating-Point Numbers C++ Arithmetic Operators Chapter 4: Compound Types Introducing Arrays Strings Introducing the string Class Introducing Structures Unions Enumerations Pointers and the Free Store Pointers, Arrays, and Pointer Arithmetic Combinations of Types Array Alternatives Chapter 5: Loops and Relational Expressions Introducing for Loops The while Loop The do while Loop The Range-Based for Loop (C++11) Loops and Text Input Nested Loops and Two-Dimensional Arrays Chapter 6: Branching Statements and Logical Operators The if Statement Logical Expressions The cctype Library of Character Functions The ?: Operator The switch Statement The break and continue Statements Number-Reading Loops Simple File Input/Output Chapter 7: Functions: C++'s Programming Modules Function Review Function Arguments and Passing by Value Functions and Arrays Functions and Two-Dimensional Arrays Functions and C-Style Strings Functions and Structures Functions and string Class Objects Functions and array Objects Recursion Pointers to Functions Chapter 8: Adventures in Functions C++ Inline Functions Reference Variables Default Arguments Function Overloading Function Templates Chapter 9: Memory Models and Namespaces Separate Compilation Storage Duration, Scope, and Linkage Namespaces Chapter 10: Objects and Classes Procedural and Object-Oriented Programming Abstraction and Classes Class Constructors and Destructors Knowing Your Objects: The this Pointer An Array of Objects Class Scope Abstract Data Types Chapter 11: Working with Classes Operator Overloading Time on Our Hands: Developing an Operator Overloading Example Introducing Friends Overloaded Operators: Member Versus Nonmember Functions More Overloading: A Vector Class Automatic Conversions and Type Casts for Classes Chapter 12: Classes and Dynamic Memory Allocation Dynamic Memory and Classes The New, Improved String Class Things to Remember When Using new in Constructors Observations About Returning Objects Using Pointers to Objects Reviewing Techniques A Queue Simulation Chapter 13: Class Inheritance Beginning with a Simple Base Class Inheritance: An Is-a Relationship Polymorphic Public Inheritance Static and Dynamic Binding Access Control: protected Abstract Base Classes Inheritance and Dynamic Memory Allocation Class Design Review Chapter 14: Reusing Code in C++ Classes with Object Members Private Inheritance Multiple Inheritance Class Templates Chapter 15: Friends, Exceptions, and More Friends Nested Classes Exceptions Runtime Type Identification Type Cast Operators Chapter 16: The string Class and the Standard Template Library The string Class Smart Pointer Template Classes The Standard Template Library Generic Programming Function Objects (a.k.a. Functors) Algorithms Other Libraries Chapter 17: Input, Output, and Files An Overview of C++ Input and Output Output with cout Input with cin File Input and Output Incore Formatting Chapter 18: Visiting with the New C++ Standard C++11 Features Revisited Move Semantics and the Rvalue Reference New Class Features Lambda Functions Wrappers Variadic Templates More C++11 Features Language Change What Now? Appendixes A Number Bases B C++ Reserved Words C The ASCII Character Set D Operator Precedence E Other Operators F The stringTemplate Class G The Standard Template Library Methods and Functions H Selected Readings and Internet Resources I Converting to ISO Standard C++ J Answers to Chapter Reviews