DOCSLIB.ORG

Concepts of Object-Oriented Programming Richard Berger [email protected] Johannes Kepler University Linz What This Talk Is About

Total Page：16

File Type：pdf, Size：1020Kb

Download full-text PDF Read full-text
Concepts of Object-Oriented Programming Richard Berger Richard.Berger@Jku.At Johannes Kepler University Linz What This Talk Is About Concepts of Object-Oriented Programming Richard Berger [email protected] Johannes Kepler University Linz What this talk is about • Introduction to Objects & Classes • Building objects • Composition • Encapsulation • Inheritance • Polymorphism • Best practices • Recommendations • Design Patterns • Conclusion • Pro & Cons of OOP What is Object-Oriented Programming? • OOP started in 1960s (Simula, SmallTalk) • Using objects as basic unit of computation message Object • Allows to extend type system • Usage: just like basic types (int, double, float, char, …) Object message • But with own structure and behavior • Static Languages (C++) message Object Types are known at compile time • Dynamic Languages (Python) Types can be manipulated at runtime I. Objects & Classes Defining new objects, object lifetime Where are these “objects”? • Objects exist in memory at runtime • Just like objects of primitive types (integers, floating-point numbers) • We can interpret 4 bytes of data as integer number • We can interpret 8 bytes of data as floating point number • In C we have structs to create composite types containing multiple primitive types • In C++ and other OOP languages this is further extended by associating behavior to a chunk of data through specifying methods to manipulate that data. Object • State • all properties of an object • Behavior • How an object reacts to interactions, such as calling a certain method • In OOP speak: Response of an object when sending it messages • Identity • Multiple objects can have the same state and behavior, but each one is a unique entity Structure and Behavior of similar objects is defined by their class. An object is also called an instance of a class. Classes Class • defines memory structure of objects • how we can interact with objects class Vector2D • how it reacts to interactions { public: Member Variable double x; • A variable in the scope of a class double y; • All instances allocate memory for their variables double length() Member Method { • A method which can be called for an object of the class. • Can access and modify the object state by manipulating return sqrt(x*x + y*y) member variables. } }; Interface • All methods which can be called on an object from outside. Lifetime of an Object Allocation • Allocation • Allocate enough memory to store object data/state Initialization • Initialization • Set an initial object state • Usage Usage • Interact with objects through methods • Access and modify object data • Cleanup Cleanup • Make sure that everything is in order before deletion • Deletion • Memory is freed, object ceases to exist Deletion Allocation Allocation Initialization Static / Stack Allocation Usage Stack void foo(int param1, int param2) param1 { double a = 30.0; param2 Cleanup double b = 50.0; a b Vector2D v; Deletion … v } x y + Fast + Automatic cleanup - Not persistent - “Limited” storage Allocation Allocation Initialization Dynamic / Heap Allocation Usage Stack Heap void foo(int param1, int param2) param1 { double a = 30.0; param2 Cleanup double b = 50.0; a Vector2D * v = new Vector2D; b Pointer Deletion v … x } y + Persistent + “Infinite” storage - Slow - Manual cleanup Allocation Initialization Initialization class Vector2D { Usage public: Vector2D(){ Constructors x = 0.0; • special methods which Cleanup y = 0.0; initialize an instance of a class } • multiple variants with Deletion Vector2D(double x1, double y1){ different parameters possible x = x1; • initialize member variables y = y1; } }; Vector2D v1(); Vector2D v2(10.0, 20.0); Vector2D * v3 = new Vector2D(); Vector2D * v3 = new Vector2D(10.0, 20.0); Allocation Usage Initialization Stack Objects Heap Objects Usage Vector2D v; Vector2D * pv = new Vector2D(); Cleanup // access members // access members v.x = 10.0; pv->x = 10.0; Deletion v.y = 20.0; pv->y = 20.0; // call member functions // call member functions double len = v.length(); double len = pv->length(); Allocation Cleanup Initialization class MyVector { Destructor Usage double * data; • Cleanup before destruction public: • Free any acquired resources MyVector( dim){ int (file handles, heap memory) Cleanup data = new double[dim]; } Deletion ~MyVector() { delete [] data; } }; Allocation Deletion Initialization Static / Stack Objects Usage Stack void foo(int param1, int param2) param1 { double a = 30.0; param2 Cleanup double b = 50.0; a b Vector2D v; Deletion v.x = 10.0; v v.y = 20.0; x … End of Scope y } objects on stack are automatically deleted at end of scope Allocation Deletion Initialization Dynamic / Heap Objects Usage Stack Heap void foo(int param1, int param2) param1 { double a = 30.0; param2 Cleanup double b = 50.0; a Vector2D * v = new Vector2D; b Pointer Deletion v->x = 10.0; v v->y = 20.0; x y … delete v; objects on heap must be deleted explicitly } Static class members Static Member Variable • Only a single instance of this variables exists class Point2D • Much like a global variable { • Can be accessed by all instances static int numPoints = 0; • Access by class name using ::, not instance public: int identifier; // Definition in a single .cpp file double x; int Point2D::numPoints = 0; double y; // access without having an instance cout << Point2D::numPoints << endl; Point2D(double x1, double y1) { identifier = numPoints++; x = x1; Static Method y = y1; • A method which is not applied on a class instance, but on } the class itself • Much like a global function static void reset_count() { • Can only access and modify static member variables numPoints = 0; } // call static method, no instance required }; Point2D::reset_count(); II. Building objects Composition, Encapsulation, Inheritance, Polymorphism Low-Level Model of an Airplane Abstractions Engine 1 model domain concepts as classes Flaps Engine 2 Aileron High-Level Model of an Airplane Elevator Heading, Speed, Height Engine 3 Latitude Engine 4 Rudder Longitude Gear Composition • natural way of creating new class Boeing747 objects is by building them out { of existing objects. Engine engine1; • Complex systems are composed Engine engine2; out of simpler sub-systems Engine engine3; Engine engine4; Gear frontGear; Gear backGear; Engine Engine Engine Engine Gear Gear … … }; Boing747 Encapsulation gearUp speed Boeing747 gearDown altitude class Boeing747{ private: hidden Gear gear; • View objects as black box : public • Don’t operate directly on internal data void gearUp() { of an object // update physics • Implementation details are hidden behind … interface gear.up(); • make member variables private } visible • Use methods of the interface to perform void gearDown() { certain actions // update physics … • Some languages, e.g. C++ and Java, help gear.down(); enforce this through specifiers: public, } private, protected }; Problems without Encapsulation void Boeing747::gearDown() { class Boeing747{ if(gear.isUp()) { public: totalAirFriction += 20.0; double totalAirFriction; gear.down(); Gear gear; } void gearUp(); } void gearDown(); void Boeing747::gearUp() { double speed(); if(gear.isDown()) { }; totalAirFriction -= 20.0; gear.down(); Boeing747 * a = new Boing747(); } } a->gearDown(); ≠ a->gear.down(); void Boeing747::speed() { // function of thrust & friction Encapsulation ensures that side effects and domain knowledge are kept inside the class which is responsible for them. return … } Type hierarchies and Inheritance Base Class • Smalltalk first added the concept of inheritance • Objects of a class can inherit state and behavior of a base class and make adjustments. • Usages: Derived Class • Extend classes with new functionality • Make minor modifications • Extract common functionality. Type hierarchies and Inheritance Airplane Boeing747 Cessna206h Type hierarchies and Inheritance class Boeing747 { class Cessna206h { float longitude, latitude; float longitude, latitude; float heading, speed; float heading, speed; float altitude; float altitude; ... ... public: public: void fullThrottle() { void fullThrottle() { engine1.maxThrottle(); engine1.maxThrottle(); engine2.maxThrottle(); speed = …; engine3.maxThrottle(); } engine4.maxThrottle(); } speed = …; } } class Airplane { public: Inheritance float longitude, latitude; Common structure float heading, speed; float altitude; }; class Boeing747 : Airplane { class Cessna206h : Airplane { ... ... public: public: void fullThrottle() { void fullThrottle() { Derived classes engine1.maxThrottle(); engine1.maxThrottle(); inherit structure engine2.maxThrottle(); speed = …; of Airplane engine3.maxThrottle(); } engine4.maxThrottle(); } speed = …; } } class Airplane { public: Inheritance float longitude, latitude; float heading, speed; float altitude; virtual void fullThrottle(); Common interface }; class Boeing747 : Airplane { class Cessna206h : Airplane { ... ... public: public: void fullThrottle() { void fullThrottle() { Derived classes engine1.maxThrottle(); engine1.maxThrottle(); implement or engine2.maxThrottle(); speed = …; extend interface engine3.maxThrottle(); } of Airplane engine4.maxThrottle(); } speed = …; } } Polymorphism Boeing747 * a = new Boeing747(); • Objects of derived classes can Airplane * b = new Boeing747(); be used as base class objects. Airplane * c = new Cessna206h(); • Polymorphism allows us to // as expected: will call Boeing747::fullThrottle modify the behavior of base a->fullThrottle(); classes and replacing the implementation of methods. // NEW! will call Boeing747::fullThrottle b->fullThrottle(); • Polymorphic methods must be declared virtual (in C++) // NEW! will call Cessna206h::fullThrottle c->fullThrottle(); Polymorphism
Load more

Recommended publications
  • Java Programming Standards & Reference Guide
    Java Programming Standards & Reference Guide Version 3.2 Office of Information & Technology Department of Veterans Affairs Java Programming Standards & Reference Guide, Version 3.2 REVISION HISTORY DATE VER. DESCRIPTION AUTHOR CONTRIBUTORS 10-26-15 3.2 Added Logging Sid Everhart JSC Standards , updated Vic Pezzolla checkstyle installation instructions and package name rules. 11-14-14 3.1 Added ground rules for Vic Pezzolla JSC enforcement 9-26-14 3.0 Document is continually Raymond JSC and several being edited for Steele OI&T noteworthy technical accuracy and / PD Subject Matter compliance to JSC Experts (SMEs) standards. 12-1-09 2.0 Document Updated Michael Huneycutt Sr 4-7-05 1.2 Document Updated Sachin Mai L Vo Sharma Lyn D Teague Rajesh Somannair Katherine Stark Niharika Goyal Ron Ruzbacki 3-4-05 1.0 Document Created Sachin Sharma i Java Programming Standards & Reference Guide, Version 3.2 ABSTRACT The VA Java Development Community has been establishing standards, capturing industry best practices, and applying the insight of experienced (and seasoned) VA developers to develop this “Java Programming Standards & Reference Guide”. The Java Standards Committee (JSC) team is encouraging the use of CheckStyle (in the Eclipse IDE environment) to quickly scan Java code, to locate Java programming standard errors, find inconsistencies, and generally help build program conformance. The benefits of writing quality Java code infused with consistent coding and documentation standards is critical to the efforts of the Department of Veterans Affairs (VA). This document stands for the quality, readability, consistency and maintainability of code development and it applies to all VA Java programmers (including contractors).
    [Show full text]
  • CS 403/503: Programming Languages
    BNF for <expression> <expression> → identifier | number | CS 403 -<expression> | (<expression>) | <expression><operator><expression> Organization of Programming Languages <operator> → + | - | * | / Class 3 - August 30, 2001 Topics For Today Parse Tree Review of BNF (Chapter 2.1) Derivations and parse trees (Chapter 2.1) Binding time (Chapter 3.1) Object lifetime and storage slope * x + intercept management (Chapter 3.2) BNF Concept Review Another Parse Tree Terminal symbols: Actual items that are part of the language (0,1,+,-,*,/,etc.) Non-Terminal symbols: <expr>, <op>, etc. Rule/production: A single line of BNF Alternatives: Expressed with | Also: slope * x + intercept *: 0 or more occurrences +:1 or more occurrences 1 Binding Lifetimes • Binding lifetime: The period of time Def: A binding is an association, such between the creation and destruction of a as between an attribute and an entity, name-to-object binding • Object lifetime: The period of time or between an operation and a between the creation and destruction of symbol. an object • These don’t necessarily coincide Def: Binding time is the time at which a • EX. Reference parameters binding takes place. Possible binding times Object Lifetimes… 1. Language design time--e.g., bind operator …correspond to one of three principal symbols to operations 2. Language implementation time--e.g., bind fl. pt. storage allocation mechanisms: type to a representation Static objects: Object lifetime = program 3. Compile time--e.g., bind a variable to a type in C execution. Object bound to one storage or Java location from load time on. 4. Load time--e.g., bind a FORTRAN 77 variable to a memory cell (or a C static variable) Stack objects: Object lifetime = subroutine 5.
    [Show full text]
  • Declaring Data Member Public C
    Declaring Data Member Public C Rickard brooch stickily. Interceptive and hamulate Connie enure, but Norbert crossways extinguishes her patroness. Is Mario estimated or electrotonic when strangulating some moribundity deified deeply? Optimize for declaring data member public If dynamic allocation is necessary, prefer to keep ownership with the code that allocated it. This process of creating an object from a class is known as instantiation. Here is the quite surprising output of the program. Data attributes need not be declared; like local variables, they spring into existence when they are first assigned to. The term __________ means the ability to takemany forms. In many cases, this is not a problem, but it is a problem in some cases. Use rvalue references only in certain special cases listed below. By default, functions and data members of the class are public. How many data members should be in every class and why? Is it acceptable to omit default constructors in a class? For accessing the data, the declaration of a friend function should be done inside the body of a class starting with the keyword friend. The constructor is declared much like a normal member function but it will share the name of the class and it has no return value. Spirit would be impossible without it. The basic idea is really very simple. Giving sensible names to types and variables is much better than using obscure names that you must then explain through comments. Special member functions called constructors and destructors. This makes it impossible for the class to ensure that invariant properties of that variable are respected.
    [Show full text]
  • C++/CLI Language Specification
    Ecma/TC39-TG5/2004/25 C++/CLI Language Specification Working Draft 1.5, Jun, 2004 Public Review Document Text highlighted like this indicates a placeholder for some future action. It might be a note from the editor to himself, or an indication of the actual or expected direction of some as-yet open issue. Note: In the spirit of the "Working Draft, Standard for Programming Language C++", this is an early draft. It’s known to be incomplet and incorrekt, and it has lots of bad formatting. Publication Time: 6/17/2004 11:44 PM Table of Contents Table of Contents Introduction....................................................................................................................................................xi 1. Scope............................................................................................................................................................. 1 2. Conformance ............................................................................................................................................... 2 3. Normative references .................................................................................................................................. 3 4. Definitions .................................................................................................................................................... 4 5. Notational conventions................................................................................................................................ 7 6. Acronyms and abbreviations
    [Show full text]
  • Classes in C++
    Classes in C++ Bryce Boe 2012/08/15 CS32, Summer 2012 B Overview • Finish Sor?ng recap • Thinking object oriented recap • Classes in C++ • Building a class in C++ (real ?me demo) Sor?ng recap • Bubble sort • Inser?on sort • Selec?on sort • Merge sort • Heapsort • Quicksort Thinking object oriented recap • Language as an influence of thought process • OO concepts – Separaon of interface and implementaon – Informaon hiding – Inheritance • Wri?ng reusable code Exci?ng Note for Today • The gcc compiler now requires C++ to build – Essen?ally means parts of the gcc compiler are wriVen in C++ • hp://gcc.gnu.org/git/? p=gcc.git;a=commit;h=2b15d2ba7eb3a25d]1 5a7300f4ee7a141ee8539 Structures • Structures provide a way to organize data • Structures in C++ are essen?ally classes, not true in C Classes • an object is a variable that has member func?ons (instance methods) • a class is a data type whose variables are objects • Class – Describe the kind of values the variables hold (state) – Describe the member func?ons (behavior) Terminology • The book uses member to mean a par?cular instance of a class • The book uses members to mean aributes of a class (variables and methods) • Funcon and method are somewhat used interchangeably • Similar: – member variable = instance variable – member method = instance method Classes • Provide encapsulaon – Combining a number of items, such as variables and func?ons, into a single package, such as an object of some class (or instance of the class) Scope Resolu?on Operator • ClassName::method_name • Used to iden?fy
    [Show full text]
  • C# Programming in Depth Lecture 4: Garbage Collection & Exception
    Chair of Software Engineering C# Programming in Depth Prof. Dr. Bertrand Meyer March 2007 – May 2007 Lecture 4: Garbage Collection & Exception Handling Lisa (Ling) Liu Overview Scope and lifetime Garbage collection mechanism Exception handling C# programming lecture 4: Garbage Collection & Exception Handling 2 Scope and lifetime Scope of a variable is portion of program text within which it is declared ¾ Need not be contiguous ¾ In C#, is static: independent of data Lifetime or extent of storage is portion of program execution during which it exists ¾ Always contiguous ¾ Generally dynamic: dependent on data Class of lifetime ¾ Static: entire duration of program ¾ Local or automatic: duration of call or block execution (local variable) ¾ Dynamic: From time of allocation statement (new) to deallocation, if any. C# programming lecture 4: Garbage Collection & Exception Handling 3 Object lifetime in C# Memory allocation for an object should be made using the “new” keyword Objects are allocated onto the managed heap, where they are automatically deallocated by the runtime at “some time in the future” Garbage collection is automated in C# Rule: Allocate an object onto the managed heap using the new keyword and forget about it C# programming lecture 4: Garbage Collection & Exception Handling 4 Object creation When a call to new is made, it creates a CIL “newobj” instruction to the code module public static int Main (string[] args) { Car c = new Car(“Viper”, 200, 100); } IL_000c: newobj instance void CilNew.Car::.ctor (string, int32,
    [Show full text]
  • Generating Object Lifetime Traces with Merlin
    Generating Object Lifetime Traces with Merlin MATTHEW HERTZ University of Massachusetts, Amherst STEPHEN M BLACKBURN Australian National University J ELIOT B MOSS University of Massachusetts, Amherst KATHRYN S McKINLEY University of Texas at Austin and DARKO STEFANOVIC´ University of New Mexico ÈÖÓÖÑÑÖ× Ö ÛÖØÒ ÖÔÐÝ ÖÓÛÒ ÒÙÑ Ö Ó ÔÖÓÖÑ× Ò Ó Ø ÐÒÙ׸ × ÂÚ Ò ¸ ØØ ÖÕÙÖ Ö Ö Ò ×ÑÙÐØÓÒ ×Ô ÜÔÐÓÖØÓÒ ÙÔ Ý ÒÐÒ Ô Ö ÙÒÖ×ØÒÒ× Ó Ó ÐØÑ ÚÓÖ Ò Ò ×Ò Ó ÒÛ Ö ÐÓÖØÑ׺ ÏÒ ÒÖØÒ Ô Ø ÖÙعÓÖ ÑØÓ Ó Ó ÐØÑ× ÖÕÙÖ× ÛÓÐ¹Ô Ö Ø ÚÖÝ Ô ÓØÒØÐ Ô ÓÒØ Ò Ø ÔÖÓÖѺ Ø× ÔÖÓ × ÔÖÓØÚÐÝ ÜÔ Ò×Ú¸ Ö× ÓØÒ ÒÙÐØ Ý ÓÒÐÝ Ô ÖÓ ¸ ºº¸ ÚÖÝ ¿¾Ã ÝØ× Ó ÐÐÓ Ù× Ö Û Ï ÜØÒ Ø ×ØØ Ó Ø ÖØ ÓÖ ×ÑÙÐØÒ Ö ÐÓÖØÑ× Ò ØÛÓÛÝ׺ Ö×ظ ÚÐÓÔ ÑØÓ ÓÐÓÝ ÓÖ ×ÑÙÐØÓÒ ×ØÙ× Ó ÝÒ Ö Ò ÔÖ×ÒØ Ö×ÙÐØ× ×ÓÛÒ Ø Ó ÖÒÙÐÖØÝ ÓÒ Ø× ×ÑÙÐØÓÒ׺ Ï ×ÓÛ ØØ ÖÒÙÐÖØÝ ÓØÒ ×ØÓÖØ× ×ÑÙÐØ Ö Ö×ÙÐØ× ÛØ Ô Û ÓÖ Ó ÔÖ×ÒØ Ò Ñ×ÙÖ Ø Ô Ó ÒÛ ÐÓÖØÑ ÅÖÐÒ ÐØÑ׺ ÅÖÐÒ ØÑ×ØÑÔ× Ó Ò ÐØÖ Ù×× Ø ØÑ×ØÑÔ× Ó Ó ØÓ ÛÒ ØÝ º Ì ÅÖÐÒ ÐÓÖØÑ × ÓÒ Ö Ô ÖÓÖÑ Ý Ø × ÖÑÒØÐ Ö×ÙÐØ× ×ÓÛ ØØ ÅÖÐÒ ÒÖØ ÓÚÖ ØÛÓ ÓÖÖ× Ó ÑÒØÙ ×Ý×ØѺ ÜÔ ×ØÖ ØÒ Ø ÑØÓ ØÖ ÚÖÝ Ó ÐÐÓ Ï Ð×Ó Ù× ÅÖÐÒ ØÓ ÔÖÓ Ú×ÙÐÞØÓÒ× Ó Ô ÚÓÖ ØØ ÜÔ Ó× ÒÛ Ó ÐØÑ ÚÓÖ׺ Categories and Subject Descriptors: D.3.4 [Programming Languages]: Processors—memory management (gar- bage collection) ÒÖÐ ÌÖÑ× ÐÓÖØÑ׸ ÄÒÙ׸ È ØÓÒÐ ÃÝ ÏÓÖ× Ò ÈÖ×× Ö ×Ò¸ Ó ÐØÑ ÒÐÝ×׸ ÒÖØÓÒ This work is supported by NSF grants CCR-0219587, ITR CCR-0085792, EIA-0218262, EIA-9726401, EIA- 030609, EIA-0238027, EIA-0324845, DARPA F33615-03-C-4106, Hewlett-Packard gift 88425.1, Microsoft Re- search, and IBM.
    [Show full text]
  • Modern C++ Object-Oriented Programming
    CPP Modern C++ Object-Oriented Programming ''Combine old and newer features to get the best out of the language'' Margit ANTAL 2020 C++ - Object-Oriented Programming Course content − Introduction to C++ − Object-oriented programming − Generic programming and the STL − Object-oriented design C++ - Object-Oriented Programming References − Bjarne Stroustrup, Herb Sutter, C++ Core Guidelines, 2017. rd − M. Gregoire, Professional C++, 3 edition, John Wiley & Sons, 2014. th − S. Lippman, J. Lajoie, B. E. Moo, C++ Primer, 5 edition, Addison Wesley, , 2013. th − S. Prata, C++ Primer Plus, 6 edition, Addison Wesley, 2012. − N. Josuttis, The C++ standard library. a tutorial and reference. Pearson Education. 2012. − A. Williams, C++ Concurrency in Action:Practical Multithreading. Greenwich, CT: Manning. 2012. Module 1 Introduction to C++ Introduction to C++ Content − History and evolution − Overview of the key features ● New built-in types ● Scope and namespaces ● Enumerations ● Dynamic memory: new and delete ● Smart pointers: unique_ptr, shared_ptr, weak_ptr ● Error handling with exceptions ● References ● The const modifier Introduction to C++ History and evolution − Creator: Bjarne Stroustrup 1983 − Standards: ● The first C++ standard − 1998 (C++98, major) − 2003 (C++03, minor) ● The second C++ standard − 2011 (C++11, major) – significant improvements in language and library − 2014 (C++14, minor) − 2017 (C++17, major) Introduction to C+ History and evolution − source: https://isocpp.org/std/status Introduction to C+ History and evolution − source:
    [Show full text]
  • Name, Scope and Binding (2) in Text: Chapter 5
    Name, Scope and Binding (2) In Text: Chapter 5 N. Meng, F. Poursardar Variable • A program variable is an abstraction of a memory cell or a collection of cells • It has several attributes – Name: A mnemonic character string – Address – Type 2 Variable Attributes (continued) • Storage Bindings – Allocation o Getting a memory cell from a pool of available memory to bind to a variable – Deallocation o Putting a memory cell that has been unbound from a variable back into the pool • Lifetime – The lifetime of a variable is the time during which it is bound to a particular memory cell 3 Object Lifetime and Storage Management • Key events: creation of objects, creation of bindings, references to variables (which use bindings), (temporary) deactivation of bindings, reactivation of bindings, destruction of bindings, and destruction of objects. • Binding lifetime: the period of time from creation to destruction of a name-to-object binding. • Object lifetime: the time between the creation and destruction of an objects is the object’s lifetime: – If object outlives binding it's garbage. – If binding outlives object it's a dangling reference. • Scope: the textual region of the program in which the binding is active; we sometimes use the word scope as a noun all by itself, without an indirect object. Lifetime • If an object’s memory binding outlives its access binding, we get garbage • If an object’s access binding outlives its memory binding, we get a dangling reference • Variable lifetime begins at allocation, and ends at deallocation either by the program or garbage collector 5 Categories of Variables by Lifetimes • Static • Stack-dynamic • Explicit heap-dynamic • Implicit heap-dynamic Storage Allocation Mechanisms • Static: objects are given an absolute address that is retained throughout the program’s execution.
    [Show full text]
  • Memory Management Programming Guide
    Memory Management Programming Guide Performance 2010-06-24 PROVIDED “AS IS,” AND YOU, THE READER, ARE ASSUMING THE ENTIRE RISK AS TO ITS QUALITY Apple Inc. AND ACCURACY. © 2010 Apple Inc. IN NO EVENT WILL APPLE BE LIABLE FOR DIRECT, All rights reserved. INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES RESULTING FROM ANY DEFECT OR INACCURACY IN THIS DOCUMENT, even No part of this publication may be reproduced, if advised of the possibility of such damages. stored in a retrieval system, or transmitted, in THE WARRANTY AND REMEDIES SET FORTH ABOVE any form or by any means, mechanical, ARE EXCLUSIVE AND IN LIEU OF ALL OTHERS, ORAL OR WRITTEN, EXPRESS OR IMPLIED. No Apple electronic, photocopying, recording, or dealer, agent, or employee is authorized to make otherwise, without prior written permission of any modification, extension, or addition to this Apple Inc., with the following exceptions: Any warranty. person is hereby authorized to store Some states do not allow the exclusion or limitation of implied warranties or liability for incidental or documentation on a single computer for consequential damages, so the above limitation or personal use only and to print copies of exclusion may not apply to you. This warranty gives you specific legal rights, and you may also have documentation for personal use provided that other rights which vary from state to state. the documentation contains Apple’s copyright notice. The Apple logo is a trademark of Apple Inc. Use of the “keyboard” Apple logo (Option-Shift-K) for commercial purposes without the prior written consent of Apple may constitute trademark infringement and unfair competition in violation of federal and state laws.
    [Show full text]
  • Contents Credits & Contacts
    Overload issue 63 october 2004 contents credits & contacts Overload Editor: The Encapsulate Context Pattern Alan Griffiths Allan Kelly 6 [email protected] [email protected] Microsoft Visual C++ and Win32 Contributing Editor: Structured Exception Handling Mark Radford [email protected] Roger Orr 15 A Mini-project to Decode a Advisors: Mini-language Thomas Guest 20 Phil Bass [email protected] Garbage Collection and Object Lifetime Thaddaeus Frogley Ric Parkin 24 [email protected] Richard Blundell C++ Lookup Mysteries [email protected] Sven Rosvall 28 Advertising: Chris Lowe [email protected] Overload is a publication of the ACCU. For details of the ACCU and other ACCU publications and activities, see the ACCU website. ACCU Website: http://www.accu.org/ Information and Membership: Join on the website or contact David Hodge [email protected] Publications Officer: John Merrells [email protected] ACCU Chair: Ewan Milne [email protected] 3 Overload issue 63 october 2004 Editorial: The Buzzword Adoption Pattern? n my last editorial (in Overload 60, called “An Industry That Refuses to Learn”) I asserted that the software development industry has not made significant progress Iin the last quarter of a century. This assertion provoked enough of a response to fill the letters page in the following issue. I’m pleased about that, but at the same time, not so pleased. I’m pleased because I managed to provoke people into putting pen to paper – or rather, in this day and age, putting fingers to keyboard. I’m not so pleased because the response was one of overwhelming agreement, which is unfortunate because it suggests that any hopes I may have had that my experience is the odd one out, are false.
    [Show full text]
  • Objective-C Fundamentals
    Christopher K. Fairbairn Johannes Fahrenkrug Collin Ruffenach MANNING Objective-C Fundamentals Download from Wow! eBook <www.wowebook.com> Download from Wow! eBook <www.wowebook.com> Objective-C Fundamentals CHRISTOPHER K. FAIRBAIRN JOHANNES FAHRENKRUG COLLIN RUFFENACH MANNING SHELTER ISLAND Download from Wow! eBook <www.wowebook.com> For online information and ordering of this and other Manning books, please visit www.manning.com. The publisher offers discounts on this book when ordered in quantity. For more information, please contact Special Sales Department Manning Publications Co. 20 Baldwin Road PO Box 261 Shelter Island, NY 11964 Email: [email protected] ©2012 by Manning Publications Co. All rights reserved. No part of this publication may be reproduced, stored in a retrieval system, or transmitted, in any form or by means electronic, mechanical, photocopying, or otherwise, without prior written permission of the publisher. Many of the designations used by manufacturers and sellers to distinguish their products are claimed as trademarks. Where those designations appear in the book, and Manning Publications was aware of a trademark claim, the designations have been printed in initial caps or all caps. Recognizing the importance of preserving what has been written, it is Manning’s policy to have the books we publish printed on acid-free paper, and we exert our best efforts to that end. Recognizing also our responsibility to conserve the resources of our planet, Manning books are printed on paper that is at least 15 percent recycled
    [Show full text]