lovable
外文资料
阿凡达台词
Object landscapes and lifetimes
Technically, OOP is just about abstract data typing, inheritance, and polymorphism, but other issues can be at least as important. The remainder of this ction will cover the issues.
One of the most important factors is the way objects are created and destroyed. Where is the data for an object and how is the lifetime of the object controlled? There are different philosophies at work here. C++ takes the approach that control of efficiency is the most important issue, so it gives the programmer a choice. For maximum run-time speed, the storage and lifetime can be determined while the program is being written, by placing the objects on the stack (the are sometimes called automatic or scoped variables) or in the static storage area. This places a priority on the speed of storage allocation and relea, and control of the can be very valuable in some situations. However, you sacrifice flexibility becau you must know the exact quantity, lifetime, and type of objects while you'r
numb是什么意思
e writing the program. If you are trying to solve a more general problem such as computer-aided design, warehou management, or air-traffic control, this is too restrictive.
不同的英文
The cond approach is to create objects dynamically in a pool of memory called the heap. In this approach, you don't know until run-time how many objects you need, what their lifetime is, or what their exact type is. Tho are determined at the spur of the moment while the program is running. If you need a new object, you simply make it on the heap at the point that you need it. Becau the storage is managed dynamically, at run-time, the amount of time required to allocate storage on the heap is significantly longer than the time to create storage on the stack. (Creating storage on the stack is often a single asmbly instruction to move the stack pointer down, and another to move it back up.) The dynamic approach makes the generally logical assumption that objects tend to be complicated, so the extra overhead of finding storage and releasing that storage will not have an important impact on the creation of an object. In addition, the greater flexibility is esntial to solve the general programming problem.
breast
中俄翻译器
Java us the cond approach, exclusively]. Every time you want to create an object, you u the new keyword to build a dynamic instance of that object.
免费在线
There's another issue, however, and that's the lifetime of an object. With languages that allow objects to be created on the stack, the compiler determines how long the object lasts and can automatically destroy it. However, if you create it on the heap the compiler has no knowledge of its lifetime. In a language like C++, you must determine programmatically when to destroy the object, which can lead to memory leaks if you don’t do it correctly (and this is a common problem in C++ programs). Java provides a feature called a garbage collector that automatically discovers when an object is no longer in u and destroys it. A garbage collector is much more convenient becau it reduces the number of issues that you must track and the code you must write. More important, the garbage collector provides a much higher level of insurance against the insidious problem of memory leaks (which has brought many a C++ project to its knees).
The rest of this ction looks at additional factors concerning object lifetimes and landscapes.
ifonly1 Collections and iterators
If you don’t know how many objects you’re going to need to solve a particular problem, or how long they will last, you also don’t know how to store tho objects. How can you know how much space to create for tho objects? You can’t, since that information isn’t known until run-time.
The solution to most problems in object-oriented design ems flippant: you create another type of object. The new type of object that solves this particular problem holds references to other objects. Of cour, you can do the same thing with an array, which is available in most languages. But there’s more. This new object, generally called a qwertycontainer (also called a collection, but the Java library us that term in a different n so this book will u “container”), will expand itlf whenever necessary to accommodate everything you place inside it. So you don’t need to know how manyobjects you’re going to hold in a container. Just create a container object and let it take care of the details.
lollFortunately, a good OOP language comes with a t of containers as part of the package.
In C++, it’s part of the Standard C++ Library and is sometimes called the Standard Template Library (STL). Object Pascal has containers in its Visual Component Library (VCL). Smalltalk has a very complete t of containers. Java also has containers in its standard library. In some libraries, a generic container is considered good enough for all needs, and in others (Java, for example) the library has different types of containers for different needs: a vector (called an ArrayList in Java) for consistent access to all elements, and a linked list for consistent inrtion at all elements, for example, so you can choo the particular type that fits your needs. Container libraries may also include ts, queues, hash tables, trees, stacks, etc.
