Objective-C

Objective-C
L’ABC del Linguaggio

Giuseppe Arici § The Preacher

Giuseppe Arici
 Apple iOS & Mac OS X Addicted Developer
Superpartes Innovation Campus & H-Farm

 Group Founder & Cocoa Preacher

m
# Pragma Mark ― pragmamark.org

co
pe y ;)
ci.
sep bo
ari
giu Fan
 A Social & Lazy Connected Node

→ ot a
[ tt | in | fb | * ] / giuseppe.arici

ard n
I'm
 Mail Forwarder & Spammer

vC
giuseppe.arici@gmail.com

iOS Bootcamp

Alzi la mano chi ...

?
iOS Bootcamp

Agenda

ia & Fi losoﬁa
 Stor
tica & Fisica
M atema

iOS Bootcamp

The History

iOS Bootcamp

40 Years !

1971 1981 1991 2001 2011

iOS Bootcamp

Dennis Ritchie @ Bell Labs

1969 - 1973

iOS Bootcamp

Alan Kay @ Xerox PARC

1972 - 1980

iOS Bootcamp

Steve Jobs & Steve Wozniak @ 

1976

iOS Bootcamp

Apple Team @ Xerox PARC

1979

iOS Bootcamp

Brad Cox & Tom Love @ ITT

1980

iOS Bootcamp

Byte Magazine # Agosto1981

1981

iOS Bootcamp

The “OOPC”

1982

iOS Bootcamp

StepStone (formerly PPI)

1983

iOS Bootcamp

OOP An Evolutionary Approach

1986

iOS Bootcamp

Steve Jobs ⚡ John Sculley

1985

iOS Bootcamp

NeXT Computer (∡28°)

1986

iOS Bootcamp

NeXT ® Objective-C ⚐ StepStone

1988

iOS Bootcamp

WWW & Doom & Mathematica

☢NeXTcube

1991

iOS Bootcamp

NeXT + Sun = OpenStep API
NSObject

“Java Was Strongly Inﬂuenced by Objective-C”
Patrick Naughton, co-creator of Java Programming Language

1993

iOS Bootcamp

NeXT ⊆ Apple

1996

iOS Bootcamp

Code Name “Rhapsody”

1997

iOS Bootcamp

Mac OS X v10.0

2001

iOS Bootcamp

clas fast
se enu @p
me
xte rat rop
ion
nsio / fo
r
ert
ns in y
Objective-C 2.0

2006

gar
opt bag
ion ec new
olle
al pro c tion run
@ tim
toc OS e
ol X
iOS Bootcamp

The iPhone

2007

iOS Bootcamp

The iPhone SDK

2008

iOS Bootcamp

Chris Lattner @ 
Source: http://nondot.org/sabre/Resume.html

Director and Architect, Low-Level Tools
September 2011 - Ongoing

Senior Manager and Architect, Low-Level Tools
June 2010 - September 2011

Senior Manager of Compilers and Low-Level Tools, Compiler Architect
September 2009 - June 2010

Manager of Compilers and Low-Level Tools, Compiler Architect
July 2008 - September 2009

LLVM Compiler Group Manager and Compiler Architect
December 2006 - July 2008

Senior Compiler Engineer and Tech Lead
June 2005 - December 2006

2005

iOS Bootcamp

LLVM Compiler Infrastructure

Source:The Architecture of Open Source Applications http://www.aosabook.org/en/llvm.html

2007

iOS Bootcamp

Clang (Static Analyzer)

2009

iOS Bootcamp

^ Blocks & GCD

2009

iOS Bootcamp

Xcode 4

2010

iOS Bootcamp

Automatic Reference Counting

* Messaggio Promozionale: http://www.whymca.org/intervento/automatic-reference-counting
2011

iOS Bootcamp

@s Enu
ms
ynt wit Ob
hes hﬁ j ec
ize xed t lit
und
by e rlyi era
def
aul ng
typ
ls
t e

WWDC 2012 Session 405: Modern Objective-C by Patrick C. Beard
Modern Objective-C

Un
Sub ord Box
scr ere
ip dm ed
ting eth Exp
me od res
dec
2012

tho l ara sio
ds t ion n s
s
iOS Bootcamp

TIOBE: Top 10 July 2012

Source: http://www.tiobe.com/index.php/content/paperinfo/tpci/index.html

iOS Bootcamp

TIOBE: Long Term Trends

Source: http://www.tiobe.com/index.php/content/paperinfo/tpci/index.html

iOS Bootcamp

TIOBE: Objective-C

Programming Language of the Year

2011

Source: http://www.tiobe.com/index.php/paperinfo/tpci/Objective-C.html

iOS Bootcamp

Ipse dixit: Tom Love ⚔ C++

“Objective-C and C++ both started from C, but they
went in two very different directions. Which approach
do you prefer now?

Tom: There’s the successful direction, and then
there’s the approach that Bjarne took with C++.
In one case, it was a small, simple — dare I say,
elegant — programming language that was very
crisp and well deﬁned. In the other case it was a
pretty ugly, complicated, difﬁcult language that
had some really troublesome features. I think
those are the distinctions between the two.”

iOS Bootcamp

Intervallo !?

iOS Bootcamp

The Language

iOS Bootcamp

Fundamental Laws

iOS Bootcamp

A strict superset of C
• Objective-C is not inspired by C language like Java or C#

• Objective-C is a strict superset of the C language

• Objective-C has only added some concepts and their
associated keywords

• Like with C++, a well-written C program should be
compile-able as Objective-C

• Unlike with C++, there is no risk of incompatibility
between C names and Objective-C keywords

iOS Bootcamp

A strict superset of C

@
@"" @( ) @[ ] @{ } @private
@catch @property
@class @protected
@defs @protocol
@dynamic @public
@encode @required
@end @selector
@ﬁnally @synchronized
@implementation @synthesize SEL BOOL
@interface @throw IMP YES
nil NO

f
de
@optional @try

pe
Nil id

ty
in byref readwrite copy

s
er
ts
co i n
out oneway readonly nonatomic

ex

et
lar ble

m
nt
inout getter assign strong self

ra
i cu i l a

pa
rt va

bycopy setter retain weak super

en
pa a

dd
hi
iOS Bootcamp

Requirements

iOS Bootcamp

Objective-C
void, char, int, long, ﬂoat function pointer
c {array} sizeof signed, unsigned
c "string"
function
typedef, enum, union const, auto, static, extern

# preprocessor (type)casting
malloc, free
C Standard Library
for, do, while
if, else, switch, case int main(int argc, const char * argv[])

format speciﬁers %d %s stack vs heap
*, &, [ ]
member selection . ->
Struct break, continue, goto

iOS Bootcamp

Objective-C
Polymorphism
Message passing Subclass
Method
Class Delegation
Instance Variable Superclass
Method overriding
Inheritance
Dynamic dispatch / binding
Encapsulation
Abstraction Interface / Protocol

iOS Bootcamp

Bad News
NO namespaces ☹
Use preﬁx instead !
NSObject, NSString, ...

UIButton, UILabel, ...

ABAddressBook, ABRecord, ...

// Pragma Mark
PMDeveloper, PMEvent, ...

Draft Proposal for Namespaces in Objective-C: @namespace @using
http://www.optshiftk.com/2012/04/draft-proposal-for-namespaces-in-objective-c/

iOS Bootcamp

Class

#import

@interface @implementation

// Person.h // Person.m

#import "Person.h"

@interface Person : NSObject @implementation Person

@end @end

iOS Bootcamp

Class @interface

#import <Foundation/Foundation.h>

@interface BankAccount : NSObject
{
NSInteger _balance;
}

- (NSInteger) withdraw:(NSInteger)amount;
- (void) deposit:(NSInteger)amount;

@end

iOS Bootcamp

Class @interface


{base types
NSInteger _balance;
}
import

@end

iOS Bootcamp

Class @interface


{
NSInteger _balance;
} class deﬁnition
-
start
(NSInteger) withdraw:(NSInteger)amount;

@end

iOS Bootcamp

Class @interface


{
NSInteger _balance;
} class name

@end

iOS Bootcamp

Class @interface

extends

{
NSInteger _balance;
} parent class

@end

iOS Bootcamp

Class @interface


{
NSInteger _balance;
}

instance
variables
@end

iOS Bootcamp

Class @interface


{
NSInteger _balance;
}


@end
methods
declarations

iOS Bootcamp

Class @interface


{
NSInteger _balance;
}
class deﬁnition
- end
(void) deposit:(NSInteger)amount;

@end

iOS Bootcamp

Class @implementation
#import "BankAccount.h"

@implementation BankAccount

- (id) init {
self = [super init];
return self;
}

- (NSInteger) withdraw:(NSInteger)amount {
return amount;
}

- (void) deposit:(NSInteger)amount {
_balance += amount;
}
@end

iOS Bootcamp


interface
- (id) init {
import[super
self = init];
return self;
}

return amount;
}

_balance += amount;
}
@end

iOS Bootcamp



- (id) init {
class implementation
return self;
}
start
return amount;
}

_balance += amount;
}
@end

iOS Bootcamp



- (id) init {
return self;
}

return amount;
}
methods with
_balance += amount; bodies
}
@end

iOS Bootcamp



- (id) init {
return self;
}

return amount;
}
class implementation
end
_balance += amount;
}
@end

iOS Bootcamp

@class directive
• @class directive provides minimal information about a class.

• @class indicates that the name you are referencing is a class!

• The use of the @class is known as a forward declaration
// Rectangle.h // Rectangle.m
#import "Shape.h" #import "Rectangle.h"

@class Point; #import "Point.h"

@interface Rectangle : Shape @implementation Rectangle

- (Point *)center; - (Point *)center {
// ...
}
@end @end

iOS Bootcamp

Instance Variable Declaration
@interface MyClass : NSObject
{
@private
// Can only be accessed by instances of MyClass
NSInteger _privateIvar1;
NSString *_privateIvar2;

@protected // Default
// Can only be accessed by instances of MyClass or MyClass's subclasses
NSInteger _protectedIvar1;
NSString *_protectedIvar2;

@package // 64-bit only
// Can be accessed by any object in the framework in which MyClass is defined
NSInteger _packageIvar1;
NSString *_packageIvar2;;

@public // Never use it !
// Can be accessed by any object scope
NSInteger _publicVar1;
NSString *_publicVar2; qualiﬁers
}

iOS Bootcamp

Method & Message

iOS Bootcamp

Method Declaration
- (BOOL) writeToFile:(NSString *)path atomically:(BOOL)flag;

In other languages, might be:

bool MyClass::writeToFileAtomically(std::string path, bool flag); // C++

public virtual bool WriteToFileAtomically(string path, bool flag); // C#

public boolean writeToFileAtomically(String path, boolean flag); // Java

public function writeToFileAtomically(path, flag) // PHP

def writeToFileAtomically(self, path, flag): # Python

def writeToFileAtomically(path, flag) # Ruby

iOS Bootcamp

Method Declaration

method scope
Can be either:
+ for a class method
- for an instance method
Methods are always public !
“Private” methods deﬁned in implementation

iOS Bootcamp

Method Declaration

return type
Can be any valid data type, including:
void returns nothing
id a pointer to an object of any class
NSString * a pointer to an NSString
BOOL a boolean (YES or NO)

iOS Bootcamp

Method Declaration

method name
The method name is composed of all labels
Colons precede arguments, but are part of the method name

writeTofile:atomically:

iOS Bootcamp

Method Declaration

argument type argument name
Arguments come after or within the method name

Variadic methods can take variable arguments
- (id)stringWithFormat:(NSString *)format ...
stdarg: va_list va_start() va_arg() va_end()

iOS Bootcamp

@selector
SEL callback = @selector(writeToFile:atomically:);

data type macro to
for selector create selector
Conceptually similar to function pointer
Useful for callback type behavior

if ([helper respondsToSelector:callback]) {
[helper performSelector:callback withObject:arguments];
}

iOS Bootcamp

Message Passing
• Methods are invoked by passing messages

• Messages aren’t bound to method implementations until
runtime. The compiler converts a message expression:
[receiver message];

• into a call on a messaging function objc_msgSend:
objc_msgSend(receiver, selector);

• Any arguments passed in the message are also handed to
objc_msgSend:
objc_msgSend(receiver, selector. arg1, arg2, ...);

iOS Bootcamp

Message Passing
[data writeToFile:@"/tmp/data.txt" atomically:YES];

In other languages, might be:

data->writeToFileAtomically("/tmp/data.txt", true); // C++

data.WriteToFileAtomically("/tmp/data.txt", true); // C#

data.writeToFileAtomically("/tmp/data.txt", true); // Java

$data->writeToFileAtomically("/tmp/data.txt", TRUE); // PHP

data.writeToFileAtomically('/tmp/data.txt', True) # Python

data.writeToFileAtomically '/tmp/data.txt', true # Ruby

iOS Bootcamp

Message Passing

square brackets syntax
Nested Message Passing: [ [ ] [ ] [ [ ] ] ]

[[store data] writeToFile:[@"/tmp/data.txt" lowercaseString]
atomically:[[PMOption sharedOption] writeMode]
encoding:NSUTF8StringEncoding
error:&error];

iOS Bootcamp

Message Forwarding
• In Objective C is very common to do message forwarding
(a strategy pattern)

• When an object receives a message and it does not have a
corresponding method, it can delegates the task to another
object

- (void)forwardInvocation:(NSInvocation*)invocation {
SEL sel = [invocation selector];
if ([helper respondsToSelector:sel]) {
[invocation invokeWithTarget:helper];
} else {
[self doesNotRecognizeSelector:sel];
}
}

iOS Bootcamp

Message Terminology
• Message expression

• Message

• Selector

• Method
{ ... } // The code selected by a message

iOS Bootcamp

Self & Super
• Methods have implicit reference to owning object called self
(similar to Java and C# this, but self is a l-value)

• Additionally have access to superclass methods using super

- (void)viewWillAppear:(BOOL)animated {
[super viewWillAppear:animated];
[self reloadData];
}

iOS Bootcamp

Object
Life Cycle

iOS Bootcamp

Object Construction
• NSObject defines class method called alloc
• Dynamically allocates memory for object on the heap

• Returns new instance of receiving class

BankAccount *account = [BankAccount alloc];

• NSObject defines instance method called init
• Implemented by subclasses to initialize instance after memory has been allocated

• Subclasses commonly define several initializers (default indicated in documentation)

BankAccount *account = [[BankAccount alloc] init];

• alloc and init calls are always nested into single line
BankAccount *account = [[BankAccount alloc] init];

iOS Bootcamp

Object Construction
initWith…

• Needs to call super

• Setup instance variables

• Returns self

- (id) init {
if (self) {
_myInstanceVariable = @"Pragma Mark !";
}
return self;
}

iOS Bootcamp

Object Destruction
dealloc

• Never call explicitly

• Release all retained or copied instance variables (* if not ARC)

• Calls [super dealloc] (* if not ARC)
- (void)saveThis:(id)object {
if (_myInstanceVariable != object ) {
[_myInstanceVariable release];
_myInstanceVariable = [object retain];
}
}

- (void)dealloc {
[super dealloc];
}

iOS Bootcamp

Memory
Management

iOS Bootcamp

Memory Management
• Manual Reference Counting
• Higher level abstraction than malloc / free

• Straightforward approach, but must adhere to conventions and rules

• Automatic Reference Counting (ARC)
• Makes memory management the job of the compiler (and runtime)

• Available for: partially iOS 4+ or OS X 10.6+ / fully iOS 5+ or OS X 10.7+

• Garbage Collection
• Only available for OS X 10.5+

• Not available on iOS due to performance concerns

iOS Bootcamp

Manual Reference Counting
(Only) objective-C objects are reference counted:

• Objects start with retain count of 1

• Increased with retain

• Decreased with release, autorelease

• When count equals 0, runtime invokes dealloc

1 2 1 0

alloc retain release release

dealloc
iOS Bootcamp

Objects you create
For objects you create with [[SomeClass alloc] init] or
[myInstance copy] (without autoreleasing):

• Retain should not need to be called

• Release when you are done using it in the {code block}

- (void)someMethod {
NSArray *someArray = [[NSArray alloc] init];
_myInstanceVariable = someArray;
}

- (void)dealloc {
[super dealloc];
}

iOS Bootcamp

Objects you don’t create
For objects you don’t create (e.g. get from methods):

• Retain only when saving to instance (or static) variable

• Release only if you retained it by saving it (as in above case)

- (void)someMethod {
id anObject = [someArray objectAtIndex:0];
_myInstanceVariable = [anObject retain];
}

- (void)dealloc {
[super dealloc];
}

iOS Bootcamp

Autorelease
What if you create an object and you are returning it from a
method, how would you be able to release it?
- (NSArray *)objects {
NSArray *myArray = [[NSArray alloc] init]; ✇
}
return myArray;
Leak !

☠
NSArray *myArray = [[NSArray alloc] init];
return [myArray release];
} Crash !
NSArray *myArray = [[NSArray alloc] init]; ☺
return [myArray autorelease];
} Right !
iOS Bootcamp

Autorelease
• Instead of explicitly releasing something, you mark it for a
later release

• An object called autorelease pool manages a set of
objects to release when the pool is released

• Add an object to the release pool by calling autorelease

@autoreleasepool {
// code goes here
}

NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
// code goes here
[pool release];

iOS Bootcamp

Autorelease
• Autorelease is NOT a Garbage Collector !
It is deterministic ⌚

• Objects returned from methods are understood to be
autoreleased if name is not in implicit retained set
(alloc, new, init or copy)

• If you spawn your own thread, you’ll have to create your
own NSAutoreleasePool

• Stack based: autorelease pools can be nested

Friday Q&A 2011-09-02: Let's Build NSAutoreleasePool
http://www.mikeash.com/pyblog/friday-qa-2011-09-02-lets-build-nsautoreleasepool.html

iOS Bootcamp

Memory Management Rule

Everything that increases the retain count with
alloc, [mutable]copy[WithZone:] or retain is in
charge of the corresponding [auto]release.

From C++ to Objective-C
http://pierre.chachatelier.fr/programmation/objective-c.php

iOS Bootcamp


“Automatic Reference Counting (ARC) in Objective-C
makes memory management the job of the compiler. By
enabling ARC with the new Apple LLVM compiler, you
will never need to type retain or release again,
dramatically simplifying the development process, while
reducing crashes and memory leaks. The compiler has a
complete understanding of your objects, and releases
each object the instant it is no longer used, so apps run
as fast as ever, with predictable, smooth performance.”
(Apple, “iOS 5 for developers” – http://developer.apple.com/technologies/ios5)

iOS Bootcamp

• The Rule is still valid, but it is managed by the compiler

• No more retain, release, autorelease nor dealloc

• New lifetime qualiﬁers for objects, which includes zeroing
weak references (only available on iOS 5+ & OS X 10.7+)

• Apple provides a migration tool which is build into Xcode

iOS Bootcamp


* Messaggio Auto-Promozionale: http://www.whymca.org/intervento/automatic-reference-counting

iOS Bootcamp

Property

iOS Bootcamp

Property
• Objective-C 2.0 introduced new syntax for deﬁning
accessor code:
• Much less verbose, less error prone

• Highly conﬁgurable

• Automatically generates accessor code

• Complementary to existing conventions and technologies:
• Key-Value Coding (KVC)

• Key-Value Observing (KVO)

• Cocoa Bindings

• Core Data Simplifying Accessors

iOS Bootcamp

Property Declaration
@property(attributes) type name;

Attribute Impacts

readonly / readwrite Mutability

setter / getter API

nonatomic Concurrency

assign / retain / copy
weak / strong (* in ARC) Storage

iOS Bootcamp


Attribute Impacts


getter / setter API



@property(readonly) NSString *accountNumber;

iOS Bootcamp


Attribute Impacts


setter / getter API



@property(getter=isActive) BOOL active;

iOS Bootcamp


Attribute Impacts


getter / setter API



@property(nonatomic, retain) NSDate *createdAt;

iOS Bootcamp


Attribute Impacts


getter / setter API



@property(readwrite, copy) NSString *accountNumber;

iOS Bootcamp

Retain Cycles

Parent Child
retain

1 1
retain

iOS Bootcamp

Retain Cycles

Parent Child
retain

0 1
assign

iOS Bootcamp

Retain Cycles
assign

X unsafe_unretained
nil release

X
weak

Controller ☺nil View
as View Delegate
New with ARC in
iOS 5+ & OS X 10.7+
iOS Bootcamp

Property @interface

@interface BankAccount : NSObject {

NSString *_accountNumber;
NSDecimalNumber *_balance;
NSDecimalNumber *_fees;
BOOL _active;
}

@property(readwrite, retain) NSDecimalNumber *balance;
@property(readonly) NSDecimalNumber *fees;

@end

iOS Bootcamp

Property @interface

@interface BankAccount : NSObject {
// No more instance variable declarations !

New in
} iOS 4+ & OS X 10.6+
@property(readwrite, retain) NSDecimalNumber *balance;
@property(readonly) NSDecimalNumber *fees;

@end

iOS Bootcamp

Property @implementation


//...

@synthesize accountNumber = _accountNumber;
@synthesize balance = _balance;
@synthesize fees = _fees;
@synthesize active = _active;

//...

@end

iOS Bootcamp

Property @implementation


// No more @synthesize statements !

New in
Xcode 4.4+
(WWDC 2012)
//...

@end

iOS Bootcamp

Property Access
• Generated properties are standard methods

• Accessed through normal messaging syntax
id value = [object property];
[object setProperty:newValue];

• Objective-C 2.0 property access via dot syntax
id value = object.property;
object.property = newValue;

• Dot notation is just syntactic sugar. Still uses accessor
methods. Doesn't get/set values directly

iOS Bootcamp

Protocol

iOS Bootcamp

Protocol
• List of method declarations
• Not associated with a particular class

• Conformance, not class, is important

• Useful in deﬁning
• Methods that others are expected to implement

• Declaring an interface while hiding its particular class

• Capturing similarities among classes that aren't hierarchically related

Java / C# Interface done
Objective-C style

iOS Bootcamp

Protocol
• Deﬁning a Protocol
@protocol NSCoding

- (void)encodeWithCoder:(NSCoder *)aCoder;
- (id)initWithCoder:(NSCoder *)aDecoder;

@end

• Adopting a Protocol
@interface Person : NSObject<NSCoding> {
NSString *_name;
}
// method & property declarations
@end

iOS Bootcamp

Protocol
• Conforming to a Protocol
@implementation Person

// Partial implementation of conforming Person class

- (id)initWithCoder:(NSCoder *)coder {
if (self = [super init]) {
_name = [coder decodeObjectForKey:@"name"];
[_name retain];
}
return self;
}

- (void)encodeWithCoder:(NSCoder *)coder {
[coder encodeObject:_name forKey:@"name"];
}
@end

iOS Bootcamp

@required & @optional
• Protocols methods are required by default

• Can be relaxed with @optional directive
@protocol SomeProtocol

- (void)requiredMethod;

@optional

- (void)anOptionalMethod;
- (void)anotherOptionalMethod;

@required

- (void)anotherRequiredMethod;

@end

iOS Bootcamp

Category & Extension

iOS Bootcamp

Category
• Add new methods to existing classes
• Alternative to subclassing

• Defines new methods and can override existing

• Does not define new instance variables (* in case use Associative References)

• Becomes part of the class definition (Inherited by subclasses)

• Can be used as organizational tool

• Often used in defining “private” methods

Extending Object
Features

iOS Bootcamp

Category
• Deﬁning and using a Category
// File NSString+PMAddition.h
@interface NSString (PMAddition)
- (NSString *)trim;
@end

// File NSString+PMAddition.m
@implementation NSString (PMAddition)
- (NSString *)trim {
NSCharacterSet *cs;
cs = [NSCharacterSet whitespaceAndNewlineCharacterSet];
return [self stringByTrimmingCharactersInSet:charSet];
}
@end

#import "NSString+PMAddition.h"
// ...
NSString *string = @" A string to be trimmed";
NSLog(@"Trimmed string: '%@'", [string trim]);

iOS Bootcamp

Class Extension
• Objective-C 2.0 adds ability to deﬁne anonymous categories
• Class extension is unnamed

• Treated as class interface continuations

• Useful for implementing required “private” API

• Compiler enforces methods are implemented

Unnamed Categories

iOS Bootcamp

Class Extension
• Interface

@interface Person : NSObject {

NSUInteger _age;
}

- (NSUInteger)age;

@end

iOS Bootcamp

Class Extension
• Implementation + “Private” Method

@interface Person ()

- (void)setAge:(NSUInteger)age;

@end

@implementation Person

- (NSUInteger)age {
return _age;
}

- (void)setAge:(NSUInteger)age {
_age = age;
}

@end

iOS Bootcamp

Exception & Block

iOS Bootcamp

Exception
• Very few uses for @try, @catch, @throw, and @ﬁnally

• Reserve the use of exceptions for programming or
unexpected runtime errors (very different from Java / C#)

• NSError and the Cocoa error-delivery mechanism are
the recommended way to communicate expected errors
@try {
// do something
}
@catch (NSException *e) {
// handle exception
}
@finally {
// close resources
}

- (BOOL)removeItemAtPath:(NSString *)path error:(NSError **)error;

iOS Bootcamp

Block
• Similar to standard C functions but, in addition to
executable code, blocks may also contain variable bindings

• Also called closures (or lambdas), because they close
around variables in their scope
New in
• A nonstandard extension to C iOS 4+ & OS X 10.6+
• Used as anonymous functions

int (^myBlock)(int) = ^(int num) { return num * multipier; };

[objects sortUsingComparator:^(id firstObject, id secondObject) {
return [firstObject compare:secondObject];
}];

iOS Bootcamp

Base Type

iOS Bootcamp

Dynamic and Static Typing
• Dynamically-typed object:
id anObject;

• Just id

• Not id * (unless you really, really mean it: pointer to pointer)

• Statically-typed object:
BankAccount *anObject;

• Objective-C provides compile-time type checking

• Objective-C always uses dynamic binding

iOS Bootcamp

The nil object pointer
• Test for nil explicitly:
if (nil == person) return; // Yoda Syntax <(-_-)>

• Or implicitly:
if (!person) return;

• Can use in assignments and as arguments if expected
person = nil;
[button setTarget: nil];

• Sending a message to nil? NO Problem !
person = nil;
[person talk];

iOS Bootcamp

The BOOL typedef
• When Objective-C was developed, C had no boolean type
(C99 introduced one)

• Objective-C uses a typedef to deﬁne BOOL as a type
BOOL flag = NO;

• Macro included for initialization and comparison:
YES and NO
if (flag) { // ...
if (!flag) { // ...

if (YES == flag) { // ... use !!flag
if (NO == flag) { // ...

flag = YES;
flag = 1;

iOS Bootcamp

Foundation Framework

iOS Bootcamp

Framework
• Frameworks are functionally similar to shared libraries

• A compiled object that can be dynamically loaded into a
program's address space at runtime

• Frameworks add associated resources, header ﬁles, and
documentation

iOS Bootcamp

Foundation.framework
• Values and Strings

• Collections

• User defaults

• Archiving

• Notiﬁcations

• Tasks, timers, threads

• File system, I/O, bundles

• URL, XML, Scanner

iOS Bootcamp

NSObject
• Root Class @interface BankAccount : NSObject

• Implements many basics
• Memory management
[anObject retain];

• Introspection
if ([anObject isKindOfClass:[Person class]]) {

• Object equality

if ([obj1 isEqual:obj2]) { // NOT obj1 == obj2

• String representation (description is like toString() in Java or ToString() in C#)

NSLog(@"%@", [anObject description]);
NSLog(@"%@", anObject); // call description

iOS Bootcamp

NSString @
• General-purpose Unicode string support

• NSString objects are conceptually UTF-16 endianness

• Consistently used in Cocoa instead of “const char *”

• Objective-C string literals start with @

• NSString is immutable, NSMutableString is mutable

const char *cString = "Pragma Mark"; // C string
NSString *nsString = @"バンザイ"; // NSString @

cString = [nsString UTF8String];
nsString = [NSString stringWithCString:cString
encoding:NSUTF8StringEncoding];

iOS Bootcamp

Format Strings
• Similar to printf, but with %@ added for objects:
NSString *title = @"The Preacher";
NSString *whoami = [NSString stringWithFormat:
@"I am %@ !", title];

// whoami would be set to:
// I am The Preacher !

• Also used for logging with NSLog macro:
NSLog(@"I am a %@, I have %d items",
[array className], [array count]);

// would log something like:
// I am a NSArray, I have 42 items

iOS Bootcamp

Collections
• NSArray - ordered collection of objects

• NSDictionary - collection of key-value pairs

• NSSet - unordered collection of unique objects

• Immutable and mutable versions
• Immutable collections can be shared without side effect

• Mutable objects typically carry a performance overhead

NSDictionary *dic;
dic = [[NSDictionary alloc] initWithObjectsAndKeys:
@"ga", @"username", @"42", @"password", nil];
//nil to signify end of objects and keys.

iOS Bootcamp

Collections
• Collections can contain only objects

• Wrap primitive types in NSNumber or NSValue

• New literal syntax for:
New in
• array @[ obj, ... ]
Xcode 4.4+
• dictionary @{ key : obj, ...} (WWDC 2012)

• boxed expressions @( number or c string ) As a shortcut, number literals can be boxed without using the ( )

NSArray *a = @[@"42", @42, @"42", @3.14];

NSDictionary *d = @{ @1 : @"black", @2 : @"white"};

iOS Bootcamp

Fast Enumeration
• Added in Objective-C 2.0

• for in similar to Java / C# foreach

• Use with NSArray, NSDictionary, NSSet or with any object
of class that adopt the NSFastEnumeration protocol
NSArray *people; // ...

// Old school
for (int i = 0; i < [people count]; ++i) {
Person *person = [people objectAtIndex:i];
}

// New school
for (Person *person in people) {
}

iOS Bootcamp

Summary

iOS Bootcamp

Objective-C
• Fully C, Fully Object-Oriented, Powerful Dynamic Runtime

• Objective-C 2.0 added many useful new features:
• Garbage Collection for Mac OS X apps

• Properties, Improved Categories & Protocols

• Objective-C LLVM continues evolution:
• Blocks (Closures)

• Automatic Reference Counting

• Synthesize by default for properties

• New literals

iOS Bootcamp

Objective-C Reference Books

iOS Bootcamp

Are you bored !?

The Objective-C Programming Language
Objective-C Runtime Programming Guide
iOS Bootcamp

Questions ?

giuseppe.arici@gmail.com
thepreacher@pragmamark.org
iOS Bootcamp

What’s NeXT !?
Objective-C
ded Runtime's Delight Me
Re y
tap
ent or
loa
rog
em em

Ob ra
jec mm
nag C: M

tive ing
-C in
Ma AR

h
al D k &
atc
isp
ntr loc
Co
de

Ce t ^B
W Gen
ith er

and ou
LLV atio

Gr All ab
M n
Never Say Never Again
The Objective-C++

iOS Bootcamp

One More Thing !

iOS Bootcamp

Thanks ☺

giuseppearici.com pragmamark.org

iOS Bootcamp

Objective-C

Recommended

More Related Content

Viewers also liked (20)

Similar to Objective-C (20)

Recently uploaded (20)

Objective-C