Почему это создает утечку памяти (iPhone)?

Ваше свойство объявляется, "сохраняют" подразумевать, что оно переданный в объекте автоматически сохраняется.

Поскольку Ваш объект уже имел подсчет ссылок одного от alloc/init существует затем две ссылки, и я принимаю только один выпуск (в Вашем деструкторе).

В основном вызов к self.editMyObject действительно делает это;

-(void) setEditMyObject:(MyObject*)obj
{
  if (editMyObject)
  {
    [editMyObject release];
    editMyObject = nil;
  }

  editMyObject = [obj retain];
}

Все остальные уже покрыли, почему это вызывает утечку памяти, таким образом, я просто соглашусь с тем, как избежать 'временной' переменной и все еще предотвратить утечку памяти:

self.editMyObject = [[[MyObject alloc] init] autorelease];

Это оставит Ваш (сохранять) свойство как единственного владельца нового объекта. Точно тот же результат как Ваш второй пример, но без временного объекта.

Условно в Какао и касании Какао, любой объект создал использование [[SomeClass alloc] initX] или [SomeClass newX] создается с сохранить количеством одного. Вы ответственны за вызов [someClassInstance release] когда Вы сделаны с Вашим новым экземпляром, обычно в Вашем dealloc метод.

То, где это становится хитрым, - когда Вы присваиваете свой новый объект свойству вместо переменной экземпляра. Большинство свойств определяется как retain или copy, что означает, что они или увеличивают объект, сохраняют количество, когда установлено или делают копию объекта, оставляя оригинал нетронутым.

В Вашем примере у Вас, вероятно, есть это в Вашем .h файл:

@property (retain) MyObject *editMyObject;

Таким образом в Вашем первом примере:

// (2) property setter increments retain count to 2
self.editMyObject = 

    // (1) new object created with retain count of 1
    [[MyObject alloc] init];

// oops! retain count is now 2

Когда Вы создаете свой новый экземпляр MyObject использование alloc/init, это имеет сохранить количество одного. Когда Вы присваиваете новый экземпляр self.editMyObject, Вы на самом деле звоните -setEditMyObject: метод, который компилятор создает для Вас когда Вы @synthesize editMyObject. Когда компилятор видит self.editMyObject = x, это заменяет его [self setEditMyObject: x].

В Вашем втором примере:

MyObject *temp = [[MyObject alloc] init];
// (1) new object created with retain count of 1

self.editMyObject = temp;
// (2) equivalent to [self setEditMyObject: temp];
// increments retain count to 2

[temp release];
// (3) decrements retain count to 1

Вы держитесь за свой новый объект достаточно долго для выпуска его, таким образом, сохранить количество сбалансировано (предположение, что Вы выпускаете его в Вашем dealloc метод).

См. также стратегию Какао указателя/управления памятью

Первая версия создает объект без выпуска соответствия. Когда Вы выделение объект, это означает, что Вы - владелец того объекта. Ваш метод set, по-видимому, сохраняет объект (поскольку он должен), означая, что Вы теперь владеете объектом дважды. Вам нужен выпуск для балансировки создания объекта.

Необходимо прочитать руководство по управлению памятью Какао, если Вы планируете использовать Какао вообще. Это не твердо, после того как Вы изучаете это, но это - что-то, что необходимо изучить, или у Вас будет много проблем как это.

It was agreed and explained that the code below does not have a leak (assuming @property retain and @synthesize for editMyObject) :

//does not create memory leak
MyObject *temp = [[MyObject alloc] init];
self.editMyObject = tempt;
[temp release];

Question : is anything wrong with the following code that does not use a temp pointer ?

//does not create memory leak ?
self.editMyObject = [[MyObject alloc] init];
[editMyObject release];

To me this looks ok.