Introduction to Objective - C

Introduc)on
to
Objec)ve-‐C

Jussi
Pohjolainen

Tampere
University
of
Applied
Sciences

Background

•  Objec)ve-‐C
is
layered
on
top
of
the
C
–

language

–  Based
on
SmallTalk-‐80

–  Designed
in
early
1980s

•  NeXT
SoLware
licensed
Objec)ve-‐C
in
1988

•  Apple
Computer
acquired
NeXT
in
1996

•  Today:
na)ve
language
for
developing
Mac
OS

X
-‐
and
iPhone
-‐
apps

Class
Declara)on:
MyPoint.h

Class
Implementa)on:
MyPoint.m

Test
the
Class:
main.m

Simple
makeﬁle

MyPoint : MyPoint.m main.m
clang -fno-objc-arc -framework foundation
MyPoint.m main.m -o MyPoint

run :
./MyPoint

clean :
rm MyPoint

Compiling
and
Running

TB308POHJUS-L-2:point pohjus$ ls -al
total 32
drwxr-xr-x 6 pohjus staff 204 18 Tou 15:32 .
drwxr-xr-x 3 pohjus staff 102 18 Tou 14:52 ..
-rw-r--r--@ 1 pohjus staff 196 18 Tou 15:25 MyPoint.h
-rw-r--r--@ 1 pohjus staff 268 18 Tou 15:23 MyPoint.m
-rw-r--r--@ 1 pohjus staff 339 18 Tou 15:25 main.m
-rw-r--r--@ 1 pohjus staff 120 18 Tou 15:14 makefile
TB308POHJUS-L-2:point pohjus$ make
clang -fno-objc-arc -framework foundation MyPoint.m main.m -o MyPoint
TB308POHJUS-L-2:point pohjus$ make run
./MyPoint
2009-05-18 15:32:46.339 MyPoint[8725:807] X = 0 and Y = 0
2009-05-18 15:32:46.341 MyPoint[8725:807] X = 8 and Y = 7
TB308POHJUS-L-2:point pohjus$

Instan)a)ng
an
Object

// Declare a pointer to the object
MyPoint* point;

// Allocate memory for the object
point = [MyPoint alloc];

// Initialize the object
point = [point init];

Instan)a)ng
an
Object:
One
Liner

// Allocate and initialize the object
MyPoint* point1 = [[MyPoint alloc] init];

Messages
(Methods)

- (void) setX: (int) n;!

method
type:
return
type
selector
name
argument
type
argument

+
=
class
method

name

-‐
=
object
method

Messages,
with
Two
Arguments

Declara=on

- (void) setXAndY: (int) x: (int) y
Usage

[object setXAndY: 5: 6];
Declara=on,
be@er
way

- (void) setX: (int) x andY: (int) y
Usage

[object setX: 5 andY: 6];

MEMORY
MANAGEMENT
AND
OBJECT

LIFECYCLE

Memory
Handling
in
General

•  When
allocate
something
it
must
be
released

–  Memory
consump)on

•  In
Java,
garbage
collector
takes
care
of
the

release.
Separate
thread
looking
for
objects

that
can
be
released

•  In
Obj-‐C
and
C/C++,
programmer
is

responsible
about
the
release.

About
Pointers

•  int
a
=
5;

–  Holds
one
integer
value

–  The
integer
is
stored
in
some
memory
address

•  Where?

–  You
can
get
the
memory
address
by
using
&
in

front
of
the
variable:
&a

Example
of
Memory
Address

int main(int argc, char *argv[])
{
int a = 5;

// prints 5
NSLog(@"%i", a);

// prints something like 0x7fff5fbff9cc
NSLog(@"%p", &a);

return 0;
}

Pointers

•  Pointer
is
a
variable
that
stores
memory

address

•  int
a;

–  holds
integer
variable

•  int*
b;

–  holds
memory
address
that
points
to
integer
value

•  int*
b
=
&a;

–  Now
b
has
the
memory
address
of
a

Example
about
Pointers

#import "MyPoint.h"

{
int a = 5;
// Store a's memory address to variable b
int *b = &a;

// prints 5
NSLog(@"%i", a);

NSLog(@"%p", &a);

NSLog(@"%p", b);

// prints 5
NSLog(@"%i", *b);

return 0;
}

What
is
the
result
now?

{
int a = 5;
// Store a's memory address to variable b
int *b = &a;

if(b == &a)
{
NSLog(@"Do we go here?");
}

if(*b == a)
{
NSLog(@"What about here?");
}

return 0;
}

What
is
the
result
now?

{
int a = 5;
int *b = &a;

*b = 10;

NSLog(@"%i", a);

return 0;
}

Memory
Areas

•  Memory
can
be
divided
into
three
categories

1.  Global
or
sta)c

2.  Stack

3.  Heap

Sta)c

•  When
something
is
in
sta)c
memory,
it's
there

all
the
)me
when
app
is
running

•  So
when
star)ng
the
app,
the
memory
is

allocated
an
when
the
app
closes,
the
memory

is
deallocated

•  The
variable
is
stored
in
the
same
memory

address
all
the
)me.

Example
of
Sta)c
Memory

int thisIsStoredInStaticMemory = 5;

{
static int thisIsAlsoStoredInStaticMemory = 10;

NSLog(@"My number = %i", thisIsStoredInStaticMemory);
NSLog(@"My number = %i", thisIsAlsoStoredInStaticMemory);

return 0;
}

Stack
-‐
Memory

•  Stack
–
memoryarea
is
usually
small

•  If
you
put
too
much
"stuﬀ"
into
stack,
you

might
get
stack
overﬂow

•  Local
variables
are
stored
in
stack!

•  Variables
are
released
when
out
of
scope

Example
of
Stack
Memory

{
int stack1 = 3;

NSLog(@"My number = %i", stack1);

if(YES)
{
int stack2 = 4;
// stack2 is released from memory now.
}

// stack1 is released from memory now.
return 0;
}

Example
of
Stack
Memory

{
if(YES)
{
int stack2 = 4;
}

// Does this work?
return 0;
}

Heap
-‐
Memory

•  Heap
–
memory
is
the
large
memory
area

where
almost
all
of
the
objects
go.

•  Programmer
is
responsible
for
releasing
the

objects!

Example
of
Heap
-‐
memory

#import "MyPoint.h"

{
MyPoint* point = [MyPoint alloc];
//...
[point release];

return 0;
}

Crea)ng
a
Object

•  The
crea)on
of
an
object
is
done
in
two
parts

•  1)
Alloca)ng
memory

–  MyPoint* point = [MyPoint alloc];
•  2)
Ini)alize
object
state

–  point = [point init];
•  Combined

–  MyPoint* point = [[MyPoint alloc] init];
•  ó

–  MyPoint* point = [MyPoint new];

What
happens
in
Memory?

•  What
happens
in
here?

–  MyPoint* p = [MyPoint alloc];
•  Two
things!

–  MyPoint* p;
–  p = [MyPoint alloc];
•  p
is
in
stack
–
memory!

•  MyPoint
object
is
in
heap
memory!

Problem?

#import "MyPoint.h"

{
if(YES)
{
}

[point release];

return 0;
}

Problem?

#import "MyPoint.h"

{
point = [MyPoint alloc];

[point release];

return 0;
}

init-‐method?

•  init-‐method
is
implemented
in
NSObject
•  You
can
however
implement
your
own
init-‐
method

- (id) initWithName: (NSString*) aName
{
if(self = [super init])
{
name = aName;
}
return self;
}

Other
init-‐methods

•  Like
in
Java
and
C++,
one
can
have
mul)ple

constructors

•  In
Obj-‐C,
one
can
have
mul)ple
init-‐methods

-  (id) init
-  (id) initWithX: (int) aX;
-  (id) initWithX: (int) aX andY: (int) aY

Deallocing
Object
and
Reference
Count

•  Rules
about
reference
coun=ng

–  When
object
is
created
its
reference
count
is
set
to
1

–  Incremen)ng
the
reference
count:

•  [point retain];
–  Decreasing
reference
count

•  [point release];
–  When
reference
count
reaches
to
0,
dealloca=ng
occurs

•  ARC
will
save
you
from
this!

Reference
Count
Example

#import <Foundation/Foundation.h>

@interface Cat : NSObject
{

}

- (void) printMyRetainCount;

@end

@implementation Cat

- (void) printMyRetainCount
{
NSLog(@"Retain count = %i", [self retainCount]);
}

@end

Reference
Count
Example

{
Cat* myCat = [[Cat alloc] init];
[myCat printMyRetainCount]; // Retain count = 1

Cat* reference = myCat;
[reference retain];

[myCat release];
[myCat release]; // Deallocation

return 0;
}

dealloc
•  You
can
implement
a
dealloc
method

(void) dealloc
{
// Some code
[super dealloc];
}

Reference
Count
Example

#import <Foundation/Foundation.h> int main(int argc, char *argv[])
{
@interface Cat : NSObject ....
{ Cat* mirri = [[Cat alloc] init];
NSString* name; [mirri setName: someName];
} // What happens now?
[someName release];
- (void) setName: (NSString *) theName
}
@end Since
reference
count
is

0,
dealloca)on
occurs.

@implementation Cat This
means,
that
the
Cat

does
not
have
a
name

- (void) setName: (NSString *) theName anymore.

{
name = theName;
}
@end

Reference
Count
Example

#import <Foundation/Foundation.h> int main(int argc, char *argv[])
{
@interface Cat : NSObject ....
{ Cat* mirri = [[Cat alloc] init];
NSString* name; [mirri setName: someName];
} // What happens now?
[someName release];
}
@end
Since
reference
count
is

1,
dealloca)on
does
not

@implementation Cat
occur
and
the
Cat
s)ll

has
it's
name.

{
[name release];
name = theName;
[name retain];
}
@end

Copying
a
Object

- (void)setName:(NSString *)theName
}
[name release];
name = [theName copy];
}

Autorelease
Pool

•  Every
Founda)on
program
must
set
up

autorelease
pool
for
the
Founda)on
objects

•  Pool
keeps
track
of
your
objects
for
later

release

–  NSAutoreleasePool *pool = [[NSAutoreleasePool
alloc] init];
–  ...
–  [pool drain];

Method
Names

•  If
method
name
includes
alloc
or
copy,
it

returns
a
object
that
must
be
released

–  // Must be released
–  NSObject* object = [[NSObject alloc] init];
–  // Must be released
–  NSObject* copy = [object copy];
–  // Do not have to release
–  NSMutableString* string = [NSMutableString string];
•  The
above
string
is
released
in
Autorelease
Pool!

Problem

// Programmer A code
[[someObject giveCat] eat];

// Programmer B code
- (Cat*) giveCat
{
// Must be released!

// But where? Should the programmer who calls this method be
// responsible for deallocation of the Cat? How does the programmer
// know this?
return myCat;
}

..

Solu)on

// Programmer A code
[[someObject giveCat] eat];

// Programmer B code
- (Cat*) giveCat
{

// But where? When autopool is drained!
[myCat autorelease];
return myCat;
}

Delayed
Release

•  Autorelease
means
"send
release
message

later".

•  Release
message
is
sent
when
Autorelease

Pool
is
released

•  Autorelease
Pool
is
created
and
released
in

UIKit
programs
automa=cally!

–  Pool
is
created
at
the
beginning
of
an
event
cycle

–  Pool
is
released
at
the
end
of
an
event
cycle

Autorelease
Pools

Event
loop

Pool

released

Pool

created

App
Loaded
Wait
for
Event
Handle
event
Exit
app

Autorelease
Pool
Usage

// Method
- (Cat*) giveCat
{

// But where? When autopool is drained!
[myCat autorelease];
return myCat;
}
// Usage
Cat* someCat = [object giveCat];
// someCat will be released in some time, so if you want to hold it, use
// retain
[someCat retain];

Rules

•  If
method
name
contains
"alloc",
"new"
or

"copy",
you
must
remember
to
use
release
or
autorelease
–  Example:
alloc, newObject, mutableCopy
•  If
you
retain something,
you
must
use

release or
autorelease
•  Instance
Variables:
retain
or
copy

•  autorelease
means
"send
release later"

Cat.h

#import <Foundation/Foundation.h>

@interface Cat : NSObject
{
@private
NSString* name;
}

- (id) initWithName: (NSString*) aName;
- (void) setName: (NSString*) aName;
- (NSString*) getName;
- (void) dealloc;

@end

Cat.m

#import "Cat.h" - (void) setName: (NSString*) aName
{
@implementation Cat if(aName != name)
{
- (id) initWithName: (NSString*) aName [name release];
{ name = aName;
if(self = [super init]) [name retain];
{ }
[self setName: aName]; }
}
return self;
} - (void) dealloc
{
- (NSString*) getName [name release];
{ [super dealloc];
return name; }
}
@end

main.m

#import "Cat.h" // Get the name
NSString* name = [cat getName];
{ // Print the name
NSAutoreleasePool *pool = NSLog(name);
[[NSAutoreleasePool alloc] init];
// Release name and cat
// Create the string [cat release];
NSString* catName = [[NSString
alloc] initWithString: @"Jack"];
[pool drain];
// Create cat with the string return 0;
Cat* cat = [[Cat alloc] }

initWithName: catName];

// Just testing. This does not
deallocate catName!
[catName release];

ARC
to
the
rescue!

MANAGING
MEMORY
WITH
ARC

ARC?

•  ARC
(Automa=c
Reference
Coun=ng)

–  Compiler
does
automa/c
reference
coun/ng
by

examining
the
source
code
and
then
add
the

retain
and
release
messages
to
objects

•  Not
garbage
collec)on,
no
background

process
of
dealloca)on
of
objects!

•  Inserts
retain
and
release
statements
based

on
some
ﬁxed
rules

•  OS
X
10.7
and
iOS
5
for
all
features

Object
lose
owners

// Scenario 1
Person* jack = [[Person alloc] init];
jack = [[Person alloc] init];

// Scenario 2
Person* tina = [[Person alloc] init];
tina = nil;

// Scenario 3
if(yes) {
Person* dave = [[Person alloc] init];
}

Some
Fixed
rules

•  If
object
is
allocated
and
local
to
method,

release
statement
is
added
near
the
end
of

that
method

•  If
allocated
object
is
class
a@ribute,
release
is

added
to
dealloc

•  If
the
object
is
return
value,
it
gets
an

autorelease
statement

Guidelines

•  Don’t
call!

–  retain, release, retainCount, autorelease
or dealloc
•  You
must
use
@autoreleasepool
syntax

•  You
must
enable
ARC

–  clang -fobjc-arc -framework foundation
Car.m Motor.m main.m -o App

makeﬁle

MyPoint : Car.m Motor.m main.m
clang -fobjc-arc -framework foundation Car.m Motor.m main.m
-o App

run :
./App

clean :
rm App

Objec)ve-‐C
2.0:
@property

Objec)ve-‐C
2.0:
@synthesize

Objec)ve-‐C
2.0:
Dot
Syntax

Property
Declara)on
Aoributes:

Writability

•  You
can
decorate
a
property
with
aoributes,

example:

–  @property (readonly) int x;
•  readwrite
–  Indicates
that
the
property
is
read/write.
Default

•  readonly
–  Only
read

–  Generates
only
geoer
method

Seoer
Seman)cs

•  assign
–  Simple
seoer.
Default.

•  weak
–  Non-‐owning
rela)onship
with
an
object

–  If
object
is
deallocated,
the
property
is
set
to
nil

•  strong
–  Owning
rela)onship
with
an
object

•  copy
–  Speciﬁes
that
a
copy
of
the
object
should
be
used
for

assignment

Seoer
Seman)cs
Examples

// assign
property = newValue;

// copy
if (property != newValue)
{
[property release];
property = [newValue copy];
}

Atomicity

•  nonatomic
–  Speciﬁes
that
accessor
are
non-‐atomic.

•  Proper)es
are
atomic
by
default:

–  [_internal lock];
–  id result = [[value retain] autorelease];
–  [_internal unlock];
–  return id;

About
Strings

•  C
String

–  char * // Array of characters
•  NSString
–  Object,
that
holds
array
of
Unicode
characters

–  Is
immutable,
contents
cannot
be
changed

aLerwards!

•  NSMutableString
–  String
that
can
be
modiﬁed
aLerwards

Crea)ng
Strings

// Simple way
NSString *temp1 = @"Hello World!";

// Appending, notice that this produces new string
NSString *beginning = @"beginning";
NSString *alphaAndOmega = [beginning
stringByAppendingString:@" and end"];

Formapng

•  Formapng

–  NSString *string1 = [NSString stringWithFormat:@"A
string: %@, a float: %1.2f", @"string", 31415.9265];
–  // string1 is "A string: string, a float: 31415.93"

•  Format
Speciﬁers?

–  http://developer.apple.com/iphone/
library/documentation/Cocoa/Conceptual/
Strings/Articles/formatSpecifiers.html#//
apple_ref/doc/uid/TP40004265-SW1

NSString
methods

•  See:

–  http://developer.apple.com/documentation/
Cocoa/Reference/Foundation/Classes/
NSString_Class/Reference/NSString.html

NSMutableString methods

•  NSMutableString inherites
NSString
•  With
NSMutableString you
can
modify
the

string
with
these
methods

– appendFormat:
– appendString:
– deleteCharactersInRange:
– insertString:atIndex:
– replaceCharactersInRange:withString:
– replaceOccurrencesOfString:withString:options:range:
– setString:

Protocols?

•  Compared
to
Java,
protocols
are
interfaces

•  You
deﬁne
methods
that
some
object
must

implement

Using
Protocols

// MyProtocolName.h
// Notice that the protocol inherites NSObject
// protocol!
@protocol MyProtocolName <NSObject>
//Method declarations go here
@end

// MyObject
@interface Class: NSObject <MyProtocolName>

Protocol
as
Variable

•  In
Java

–  MyInterface object = new MyObject();
•  In
Obj-‐C

–  id<MyProtocolName> object = [[MyObject
alloc] init];
•  As
a
method
argument

–  (void) doSomethingWithThisObject:
(id<MyProtocolName>) aObject
•  ID
is
a
predeﬁned
pointer
type
for
an
arbitrary

object

NSObject

•  NSObject
is
the
root
class
of
Most
Obj-‐C

classes

•  Crea)ng,
copying,
dealloca)ng
objects

Collec)ons

•  Array:
Ordered
Collec/ons

•  Dic)onary:
Collec/ons
of
Keys
and
Values

•  Set:
Unordered
Collec/ons
of
Objects

•  Counted
Sets:
Unordered
Collec/on
of

Indis/nct
Objects

•  Enumera)on:
Traversing
a
Collec/on's

Elements

•  Mutable
and
immutable
versions!

Other
Classes

•  NSNumber,
wrapper
for
standard
number

types

•  NSDate,
NSCalendarDate

Introduction to Objective - C

More Related Content

What's hot (20)

Viewers also liked (20)

Similar to Introduction to Objective - C (20)

More from Jussi Pohjolainen (20)

Recently uploaded (20)

Introduction to Objective - C