I think that what you need to understand is how arc works.

Basically whatever has a strong pointer pointing to it will be retained.

This works by adding a reference counter in the object so when you do this:

@property (strong, nonatomic) MyObject *myObject;

you create a STRONG pointer for myObject, (not the object).

but when you do this

MyObject *myObject = [[self dataSource] objectForIndex:[indexPath row]];

you make this pointer increase the reference counting on whatever you have in the specified index from that data source.

The important part is that as long as the pointer keeps pointing to this object it will be kept alive.

About your concern with the views.

Views created in the interface builder have their elements declared internally with strong pointers. This is when you want to use a weak reference. When you add your own IBOutlet to an element in the view it is good practice to make it weak. If you think about the reason logically, it basically means that you dont care about this interface builder element since you only want it to survive until the viewcontroller is deallocated.

When you usually encounter retain cycles is when an object has a child object, and this child object has a STRONG reference to its parent.

this is:

Object A creates object B with a strong pointer

Object B points to object A with a strong pointer

A will keep B alive and B will keep A alive.

This page will explain to you some basic stuff about how to avoid this kind of stuff:

http://cocoawithlove.com/2009/07/rules-to-avoid-retain-cycles.html

Also about passing objects between views, it is very very simple.

First get a pointer from View 1 to View 2 (can be strong or weak depending on who should be keeping view 2 alive, if its from the IB Builder it should be weak if its programatically it should be strong)

Second, make a property in view 2 (@property (strong, nonatomic) MyObject *myObject;)

now it is as simple as:

Self.view1Pointer.myObject = self.myOtherObject;

Understand here how both views are strongly pointing to this object so the object will be kept alive as long as 1 of the views hasnt been deallocated.

You wont create a retain cycle, you simply have the reference counting from that object set to 2.

Note: When a view is deallocated, all of its pointers are set to nil so any object being pointed by them will decrease in its reference count. IF it reaches 0 it is deallocated. (in the previous case myobject will be 1 because another view is still pointing to it).

The only scenario where you will create a retain cycle is if you manage to make myObject point strongly to View2 as well. So now they are keeping each other alive. (but as explained before you can make myObject point to view2 weakly which wont create a retain cycle).

You can learn more about arc here:

http://www.raywenderlich.com/5677/beginning-arc-in-ios-5-part-1