Есть два новых атрибута управления памятью для свойств, представленных ARC, strongи weak.

Кроме того copy, что, очевидно, является чем-то совершенно другим, есть ли различия между strongпротив retainи weakпротив assign?

Насколько я понимаю, единственное отличие здесь в том, что он weakбудет назначать nilуказатель, а assignне будет, что означает, что программа завершится сбоем, когда я отправлю сообщение указателю после его освобождения. Но если я воспользуюсь weak, этого никогда не произойдет, потому что отправка сообщения nilне будет ничего делать.

Я не знаю никаких различий между strongи retain.

Есть ли какая-то причина, по которой я должен использовать assignи retainв новых проектах, или они устарели?

Из заметок о переходе на ARC (пример в разделе об атрибутах свойств).

// The following declaration is a synonym for: @property(retain) MyClass *myObject;

@property(strong) MyClass *myObject;

Так strong же, как retainв объявлении свойства.

Для проектов ARC я бы использовал strong вместо retain, я использовал бы assignдля примитивных свойств C и weakдля слабых ссылок на объекты Objective-C.

Прочитав так много статей, опубликованных в Stackoverflow и демонстрационных приложениях для проверки атрибутов переменных, я решил собрать всю информацию об атрибутах:

1. atomic // default
2. неатомической
3. strong = сохранить // по умолчанию
4. слабый
5. сохранить
6. назначить // по умолчанию
7. unsafe_unretained
8. копия
9. только для чтения
10. readwrite // по умолчанию

Ниже приведена подробная ссылка на статью, где вы можете найти все вышеупомянутые атрибуты, которые определенно вам помогут. Большое спасибо всем людям, которые дают лучшие ответы здесь!

Атрибуты переменных свойств или модификаторы в iOS

1. сильный (iOS4 = сохранить)

• там написано "держи это в куче, пока я не укажу на это"
• Другими словами, «Я владелец, вы не можете сдать это, пока не нацелились на то же самое, что и удержали»
• Вы используете сильный, только если вам нужно сохранить объект.
• По умолчанию все переменные экземпляра и локальные переменные являются сильными указателями.
• Обычно мы используем сильный для UIViewControllers (родителей элемента пользовательского интерфейса)
• Сильный используется с ARC, и он в основном помогает вам, не заботясь о сохранении счета объекта. ARC автоматически выпускает его для вас, когда вы закончите. Использование ключевого слова strong означает, что вы являетесь владельцем объекта.

Пример:

@property (strong, nonatomic) ViewController *viewController;

@synthesize viewController;

2. слабый -

• он говорит: «Держите это, пока кто-то еще сильно на это указывает»
• то же самое, что присваивать, не сохранять или освобождать
• «Слабая» ссылка - это ссылка, которую вы не сохраняете.
• Как правило, мы используем слабый для IBOutlets (Childs UIViewController). Это работает, потому что дочерний объект должен существовать только столько, сколько родительский объект делает.
• слабая ссылка - это ссылка, которая не защищает указанный объект от сбора сборщиком мусора.
• Слабым является, по сути, присваиваемое, оставшееся свойство. За исключением случаев, когда объект освобожден, слабый указатель автоматически устанавливается на ноль

Пример :

@property (weak, nonatomic) IBOutlet UIButton *myButton;

@synthesize myButton;

Сильное и слабое объяснение, благодаря BJ Homer :

Представьте, что наш объект - собака, и что собака хочет убежать (быть освобожденной).

Сильные указатели похожи на поводок на собаку. Пока вы привязали поводок к собаке, собака не убежит. Если пять человек прикрепят поводок к одной собаке (пять сильных указателей на один объект), то собака не убежит, пока все пять поводков не отсоединятся.

Слабые указатели, с другой стороны, похожи на маленьких детей, указывающих на собаку и говорящих "Смотри! Собака!" Пока собака все еще на поводке, маленькие дети все еще могут видеть собаку, и они все еще будут указывать на нее. Однако, как только поводки отстегнуты, собака убегает независимо от того, сколько на нее указывают маленькие дети.

Как только последний сильный указатель (привязь) больше не указывает на объект, объект будет освобожден, а все слабые указатели будут обнулены.

Когда мы используем слабые?

Единственный раз, когда вы захотите использовать слабый, - это если вы хотите избежать циклов сохранения (например, родитель сохраняет ребенка, а ребенок сохраняет родителя, поэтому ни один из них не освобождается).

3. сохранить = сильный

• оно сохраняется, старое значение освобождается и ему присваивается сохранение, указывает, что новое значение должно быть отправлено
• сохранить при назначении и старое значение отправлено
• сохранить так же, как сильный.
• Apple говорит, что если вы напишите сохранить, он будет автоматически конвертироваться / работать как сильный.
• такие методы, как «alloc», включают в себя неявное «retain»

Пример:

@property (nonatomic, retain) NSString *name;

@synthesize name;

4.assign

• assign является значением по умолчанию и просто выполняет присвоение переменной
• assign - это атрибут свойства, который сообщает компилятору, как синтезировать реализацию метода установки свойства
• Я хотел бы использовать для примитивных свойств Си и слабые для слабых ссылок на объекты Objective-C.

Пример:

@property (nonatomic, assign) NSString *address;

@synthesize address;

неатомический / атомный

• неатомный намного быстрее, чем атомный
• всегда используйте nonatomic, если у вас нет особых требований к atomic, что должно быть редко (atomic не гарантирует безопасность потока - блокирует доступ к свойству, только если он одновременно установлен другим потоком)

сильный / слабый / правопреемник

• использовать сильный для сохранения объектов - хотя ключевое слово retain является синонимом, вместо него лучше использовать strong
• использовать слабый если вам нужен только указатель на объект без его сохранения - полезно для избежания сохранения циклов (т. е. делегатов) - он автоматически обнулит указатель при освобождении объекта
• используйте assign для приматов - точно так же, как и слабый, за исключением того, что он не обнуляет объект при освобождении (устанавливается по умолчанию)

(Необязательный)

копия

• использовать его для создания мелкой копии объекта
• Рекомендуется всегда задавать неизменяемые свойства для копирования - поскольку изменяемые версии могут передаваться в неизменяемые свойства, копирование гарантирует, что вы всегда будете иметь дело с неизменным объектом
• если передан неизменный объект, он сохранит его - если передан изменяемый объект, он скопирует его

только для чтения

• используйте его, чтобы отключить настройку свойства (предотвращает компиляцию кода при нарушении)
• вы можете изменить то, что доставляет получатель, либо изменяя переменную напрямую через переменную экземпляра, либо внутри самого метода получателя.

Насколько я знаю, strongи retainэто синонимы, поэтому они точно делают же.

Тогда weakон почти такой же assign, но автоматически устанавливается равным nil после того, как объект, на который он указывает, освобожден.

Это означает, что вы можете просто заменить их.

Тем не менее , есть один особый случай, с которым я столкнулся, где я должен был использовать assign, а не weak. Допустим, у нас есть два свойства delegateAssignи delegateWeak. В обоих хранится наш делегат, который владеет нами, имея единственную сильную ссылку. Делегат освобождается, поэтому и наш -deallocметод тоже вызывается.

// Our delegate is deallocating and there is no other strong ref.
- (void)dealloc {
    [delegateWeak doSomething];
    [delegateAssign doSomething];
}

Делегат уже находится в процессе освобождения, но еще не полностью освобожден. Проблема в том, что weakссылки на него уже аннулированы! Свойство delegateWeakсодержит ноль, но delegateAssignсодержит действительный объект (все свойства уже освобождены и аннулированы, но все еще действительны).

// Our delegate is deallocating and there is no other strong ref.
- (void)dealloc {
    [delegateWeak doSomething]; // Does nothing, already nil.
    [delegateAssign doSomething]; // Successful call.
}

Это особый случай, но он показывает нам, как weakработают эти переменные и когда они обнуляются.

В документе Кланга об Objective-C Автоматический подсчет ссылок (ARC) четко разъясняются квалификаторы и модификаторы владения:

Существует четыре классификатора собственности:

• __ autoreleasing
• __ сильный
• __ * unsafe_unretained *
• __ слабый

Тип нетривиально квалифицирован как владелец, если он квалифицирован как __utoreleasing , __ strong или __ слабый .

Тогда есть шесть модификаторов собственности для объявленной собственности:

• правопреемником подразумевает __ * unsafe_unretained * владение.
• Копирование подразумевает ___ сильное владение, а также обычное поведение семантики копирования в установщике.
• сохранить подразумевает __ сильную собственность.
• сильный подразумевает __ сильный собственность.
• * unsafe_unretained * подразумевает __ * unsafe_unretained * владение.
• слабая подразумевает __ слабую собственность.

За исключением слабых , эти модификаторы доступны в не-ARC режимах.

В семантике квалификаторы владения имеют различное значение в пяти управляемых операциях : чтение, назначение, инициализация, уничтожение и перемещение, в которых в большинстве случаев мы заботимся только о разнице в операции назначения.

присваивание происходит при оценке оператора присваивания. Семантика варьируется в зависимости от квалификации:

• За __ сильных объектов новый указатель сначала сохраняется; во-вторых, lvalue загружается примитивной семантикой; в-третьих, новый pointee сохраняется в lvalue с примитивной семантикой; и, наконец, старый pointee освобожден. Это не выполняется атомарно; внешняя синхронизация должна использоваться, чтобы сделать это безопасным перед лицом одновременных нагрузок и хранилищ.
• Для __ слабых объектов значение lvalue обновляется, чтобы указывать на новый указатель, если только этот указатель не является объектом, который в настоящее время подвергается освобождению, и в этом случае значение lvalue обновляется до нулевого указателя. Это должно выполняться атомарно по отношению к другим присваиваниям объекту, чтению из объекта и окончательному выпуску нового pointee.
• Для объектов __ * unsafe_unretained * новый pointee сохраняется в lvalue с использованием примитивной семантики.
• Для ___ автоматически высвобождаемых объектов новый pointee сохраняется, автоматически высвобождается и сохраняется в lvalue с использованием примитивной семантики.

Другое различие в Чтении, Инициировании, Разрушении и Перемещении, пожалуйста, обратитесь к Разделу 4.2 Семантика в документе .

Чтобы понять сильные и слабые ссылки, рассмотрим пример ниже. Предположим, у нас есть метод с именем displayLocalVariable.

 -(void)displayLocalVariable
  {
     NSString myName = @"ABC";
     NSLog(@"My name is = %@", myName);
  }

В приведенном выше методе область действия переменной myName ограничена методом displayLocalVariable, как только метод завершится, переменная myName, содержащая строку «ABC», будет освобождена из памяти.

Теперь, что если мы хотим сохранить значение переменной myName на протяжении всего жизненного цикла контроллера представления. Для этого мы можем создать свойство с именем username, которое будет иметь ссылку Strong на переменную myName (см. self.username = myName;Код ниже), как показано ниже:

@interface LoginViewController ()

@property(nonatomic,strong) NSString* username;
@property(nonatomic,weak) NSString* dummyName;

- (void)displayLocalVariable;

@end

@implementation LoginViewController

- (void)viewDidLoad
{
    [super viewDidLoad];

}

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

- (void)displayLocalVariable
{
   NSString myName = @"ABC";
   NSLog(@"My name is = %@", myName);
   self.username = myName;
}

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


@end

Теперь в приведенном выше коде вы можете видеть, что myName было назначено для self.username, а self.username имеет сильную ссылку (как мы объявили в интерфейсе с использованием @property) на myName (косвенно это имеет сильную ссылку на строку «ABC»). Следовательно, строка myName не будет освобождена из памяти, пока self.username не станет активным.

• Слабая ссылка

Теперь рассмотрите возможность присвоения myName dummyName, который является слабой ссылкой, self.dummyName = myName; В отличие от Strong reference, Weak будет хранить myName только до тех пор, пока не будет Strong reference для myName. Посмотрите код ниже, чтобы понять слабую ссылку,

-(void)displayLocalVariable
  {
     NSString myName = @"ABC";
     NSLog(@"My name is = %@", myName);
     self.dummyName = myName;
  }

В приведенном выше коде есть Слабая ссылка на myName (т. Е. Self.dummyName имеет Слабую ссылку на myName), но нет строгой ссылки на myName, поэтому self.dummyName не сможет содержать значение myName.

Теперь снова рассмотрим приведенный ниже код,

-(void)displayLocalVariable
      {
         NSString myName = @"ABC";
         NSLog(@"My name is = %@", myName);
         self.username = myName;
         self.dummyName = myName;
      } 

В приведенном выше коде self.username имеет ссылку Strong на myName, поэтому self.dummyName теперь будет иметь значение myName даже после завершения метода, поскольку myName имеет ссылку Strong, связанную с ним.

Теперь всякий раз, когда мы делаем ссылку Strong на переменную, количество сохраняемых данных увеличивается на единицу, и переменная не освобождается, а количество сохраняемых данных достигает 0.

Надеюсь это поможет.

Strong:

• Свойство не будет уничтожено, но только после того, как вы установите свойство равным нулю, объект будет уничтожен
• По умолчанию все переменные экземпляра и локальные переменные являются сильными указателями.
• Вы используете сильный, только если вам нужно сохранить объект.
• Обычно мы используем сильный для UIViewControllers (родителей элемента пользовательского интерфейса)
• IOS 4 (не ARC) мы можем использовать сохранить ключ
• IOS 5 (ARC) мы можем использовать сильное ключевое слово

Пример: @property (сильный, неатомный) ViewController * viewController;

@synthesize viewController;

слабый

По умолчанию автоматически получить и установить на ноль

• Обычно мы используем слабый для IBOutlets (UIViewController's Childs) и делегировать
• то же самое, что присваивать, не сохранять или освобождать

Пример: @property (слабый, неатомный) IBOutlet UIButton * myButton;

@synthesize myButton;

Различия между сильным и сохранением:

• В iOS4 сильный равен удержанию
• Это означает, что вы владеете объектом и держите его в куче до тех пор, пока не укажете на него.
• Если вы напишите сохранить, он будет автоматически работать так же, как сильный

Различия между слабым и назначаемым:

• «Слабая» ссылка - это ссылка, которую вы не сохраняете и сохраняете до тех пор, пока кто-то на нее сильно указывает
• Когда объект «освобожден», слабый указатель автоматически устанавливается на ноль
• Атрибут свойства «assign» сообщает компилятору, как синтезировать реализацию метода установки свойства