- Title Page
- Copyright Page
- Dedication Page
- Contents
- New Features in C++11
- Preface
- Chapter 1. Getting Started
- Part I. The Basics
- Contents
- Chapter 2. Variables and Basic Types
- Chapter 3. Strings, Vectors, and Arrays
- Chapter 4. Expressions
- Contents
- 4.1. Fundamentals
- 4.2. Arithmetic Operators
- 4.3. Logical and Relational Operators
- 4.4. Assignment Operators
- 4.5. Increment and Decrement Operators
- 4.6. The Member Access Operators
- 4.7. The Conditional Operator
- 4.8. The Bitwise Operators
- 4.9. The sizeof Operator
- 4.10. Comma Operator
- 4.11. Type Conversions
- 4.12. Operator Precedence Table
- Chapter Summary
- Defined Terms
- Chapter 5. Statements
- Chapter 6. Functions
- Chapter 7. Classes
- Part II. The C++ Library
- Contents
- Chapter 8. The IO Library
- Chapter 9. Sequential Containers
- Chapter 10. Generic Algorithms
- Chapter 11. Associative Containers
- Chapter 12. Dynamic Memory
- Part III. Tools for Class Authors
- Contents
- Chapter 13. Copy Control
- Chapter 14. Overloaded Operations and Conversions
- Contents
- 14.1. Basic Concepts
- 14.2. Input and Output Operators
- 14.3. Arithmetic and Relational Operators
- 14.4. Assignment Operators
- 14.5. Subscript Operator
- 14.6. Increment and Decrement Operators
- 14.7. Member Access Operators
- 14.8. Function-Call Operator
- 14.9. Overloading, Conversions, and Operators
- Chapter Summary
- Defined Terms
- Chapter 15. Object-Oriented Programming
- Contents
- 15.1. OOP: An Overview
- 15.2. Defining Base and Derived Classes
- 15.3. Virtual Functions
- 15.4. Abstract Base Classes
- 15.5. Access Control and Inheritance
- 15.6. Class Scope under Inheritance
- 15.7. Constructors and Copy Control
- 15.8. Containers and Inheritance
- 15.9. Text Queries Revisited
- Chapter Summary
- Defined Terms
- Chapter 16. Templates and Generic Programming
- Part IV. Advanced Topics
- Contents
- Chapter 17. Specialized Library Facilities
- Chapter 18. Tools for Large Programs
- Chapter 19. Specialized Tools and Techniques
- Appendix A. The Library
- Contents
- A.1. Library Names and Headers
- A.2. A Brief Tour of the Algorithms
- A.2.1. Algorithms to Find an Object
- A.2.2. Other Read-Only Algorithms
- A.2.3. Binary Search Algorithms
- A.2.4. Algorithms That Write Container Elements
- A.2.5. Partitioning and Sorting Algorithms
- A.2.6. General Reordering Operations
- A.2.7. Permutation Algorithms
- A.2.8. Set Algorithms for Sorted Sequences
- A.2.9. Minimum and Maximum Values
- A.2.10. Numeric Algorithms
- A.3. Random Numbers
- Index
- Add Pages
Contents
Section 12.1 Dynamic Memory and Smart Pointers
Section 12.3 Using the Library: A Text-Query Program
The programs we’ve written so far have used objects that have well-defined lifetimes. Global objects are allocated at program start-up and destroyed when the program ends. Local, automatic objects are created and destroyed when the block in which they are defined is entered and exited. Local static objects are allocated before their first use and are destroyed when the program ends.
In addition to supporting automatic and static objects, C++ lets us allocate objects dynamically. Dynamically allocated objects have a lifetime that is independent of where they are created; they exist until they are explicitly freed.
Properly freeing dynamic objects turns out to be a surprisingly rich source of bugs. To make using dynamic objects safer, the library defines two smart pointer types that manage dynamically allocated objects. Smart pointers ensure that the objects to which they point are automatically freed when it is appropriate to do so.
Our programs have used only static or stack memory. Static memory is used for local static objects (§ 6.1.1, p. 205), for class static data members (§ 7.6, p. 300), and for variables defined outside any function. Stack memory is used for nonstatic objects defined inside functions. Objects allocated in static or stack memory are automatically created and destroyed by the compiler. Stack objects exist only while the block in which they are defined is executing; static objects are allocated before they are used, and they are destroyed when the program ends.
In addition to static or stack memory, every program also has a pool of memory that it can use. This memory is referred to as the free store or heap. Programs use the heap for objects that they dynamically allocate—that is, for objects that the program allocates at run time. The program controls the lifetime of dynamic objects; our code must explicitly destroy such objects when they are no longer needed.
Warning-
No Comment