Атрибуты свойств в Objective-C. Инструкция для начинающих20.08.2015 18:03

image

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

Краткое вступление


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

Непосредственно, инструкция


Для начала поделим все атрибуты, которые есть у свойства, на группы:

  1. атрибуты доступности (readonly/readwrite),
  2. атрибуты владения (retain/strong/copy/assign/unsafe_unretained/weak),
  3. атрибут атомарности (atomic/nonatomic).


Атрибуты, позволяющие задать имя сеттера и геттера, рассматривать не будем — для них как таковых правил нет, за исключением тех, что предусматривает используемый вами Code Style. Явно или неявно, но атрибуты всех типов указываются у каждого свойства.Атрибуты доступности

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


  • readonly — указывает, что свойство доступно только для чтения. Это значение стоит применять в случаях, когда изменение свойства «снаружи» во время выполнения объектом своей задачи нежелательно, либо когда значение свойства не хранится ни в какой переменной, а генерируется исходя из значений других свойств. Например, есть у объекта User свойства firstName и lastName, и для удобства заданное readonly свойство fullName, значение которого генерируется исходя из значений первых двух свойств.


В случае, когда нежелательно изменение свойства «снаружи», оно, как правило, объявляется в интерфейсе класса как readonly, а потом переопределяется как readwrite в расширении класса (class extension), чтобы внутри класса также изменять значение не напрямую в переменной, а через сеттер.Атрибуты владения
Это самый обширный тип атрибутов, во многом из-за сосуществования ручного и автоматического управления памятью.
При включенном ARC у переменных, как и у свойств, есть атрибут владения, только в этом случае набор значений меньше, чем у свойств: __strong/__weak/__unsafe_unretained, и касается это только тех типов данных, которые подпадают под действие ARC (особенности для типов данных, не попадающих под действие ARC здесь рассматривать не будем, чтобы не усложнять то, что призвано быть простой шпаргалкой). Поэтому при описании значений этого атрибута для свойств будем еще указывать, какое значение атрибута владения должно быть у соответствующей переменной экземпляра при включенном ARC (если переменная создается автоматически — она сразу создается с нужным значением этого атрибута. Если же вы определяете переменную сами — нужно вручную задать ей правильное значение атрибута владения).

  • retain (соответствующая переменная должна быть с атрибутом __strong) — это значение показывает, что в сгенерированном сеттере счетчик ссылок на присваиваемый объект будет увеличен, а у объекта, на который свойство ссылалось до этого, — счетчик ссылок будет уменьшен. Это значение применимо при выключенном ARC для всех Objective-C классов во всех случаях, когда никакие другие значения не подходят. Это значение сохранилось со времен, когда ARC еще не было и, хотя ARC и не запрещает его использование, при включенном автоматическом подсчете ссылок лучше вместо него использовать strong.
  //примерно вот такой сеттер будет сгенерирован для свойства 
//с таким значением атрибута владения с отключенным ARC
-(void)setFoo(Foo *)foo {
  if (![_foo isEqual:foo]) {
    //уменьшается счетчик ссылок на объект, на который раньше указывало свойство
    [_foo release]; 

    //затем увеличивается счетчик ссылок на новый объект и укзатель на него сохраняется в ivar
    _foo = [foo retain];
  }
}


  • strong (соответствующая переменная должна быть с атрибутом __strong) — это значение аналогично retain, но применяется только при включенном автоматическом подсчете ссылок. При использовании ARC это значение используется по умолчанию. Используйте strong во всех случаях, не подходящих для weak и copy, и все будет хорошо.


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


  1. класс должен поддерживать протокол NSCopying,
  2. класс не должен быть изменяемым (mutable). У некоторых классов есть mutable-подкласс, например, NSString-NSMutableString. Если ваше свойство — экземпляр «мутабельного» класса, использование copy приведет к нежелательным последствиям, так как метод copy вернет экземпляр его «немутабельного» сородича. Например, вызов copy у экземпляра NSMutableString вернет экземпляр NSString.


Пример: 

@property (copy, nonatomic) NSMutableString *foo;
        ...
        //в сгенерированном сеттере будет примерно следующее
- (void)setFoo:(NSMutableString)foo {
    _foo = [foo copy]; //метод copy класса NSMutableString вернет объект типа NSString, так что после присвоения значения этому свойству, оно будет указывать на неизменяемую строку, и вызов методов, изменяющих строку, у этого объекта приведет к крэшу
}


Из второго ограничения вытекает самая главная причина использования значения copy: все публичные свойства, являющиеся экземплярами класса, у которого есть «мутабельный» подкласс, лучше всего создавать именно с этим значением атрибута владения. У «немутабельных» классов метод copy работает как retain — никакого копирования не произойдет, лишняя память и время израсходованы не будут, но при этом свойство будет защищено от задания экземпляра «мутабельного» подкласса. Например, в свойство типа NSArray нельзя будет задать объект класса NSMutableArray, а значит и изменить свойство «снаружи», минуя сеттер, будет нельзя.

Пример: 

@interface Foo : NSObject
…
@property (copy, nonatomic) NSArray *bar;
@property (strong, nonatomic) NSArray *barNotProtected;
…
@end

…
NSMutableArray *mutableArray = [@[@1, @2, @3] mutableCopy];
Foo *foo = [Foo new];
foo.bar = mutableArray; //в bar будет указатель на неизменяемую копию массива
foo.barNotProtected = mutableArray; //а в barNotProtected будет записан указатель на изменяемый массив
[mutableArray removeObjectAtIndex:0]; //теперь foo.barNotProtected указывает на измененный массив (@[@2, @3]), а массив, на который указывает foo.bar никак не изменился (@[@1, @2, @3]).


  • weak (соответствующая переменная должна быть с атрибутом __weak) — это значение аналогично assign и unsafe_unretained. Разница в том, что особая уличная магия позволяет переменным с таким значением атрибута владения менять свое значение на nil, когда объект, на который указывала переменная, уничтожается, что очень хорошо сказывается на устойчивости работы приложения (ибо, как известно, nil отвечает на любые сообщения, а значит никаких вам EXC_BAD_ACCESS при обращении к уже удаленному объекту). Это значение атрибута владения стоит использовать при включенном ARC для исключения retain cycle«ов для свойств, в которых хранится указатель на делегат объекта и им подобных. Это единственное значение атрибута владения, которое не поддерживается при выключенном ARC (как и при включенном ARC на iOS до версии 5.0).


  • unsafe_unretained (соответствующая переменная должна быть с атрибутом __unsafe_unretained) — свойство с таким типом владения просто сохраняет адрес присвоенного ему объекта. Методы доступа к такому свойству никак не влияют на счетчик ссылок объекта. Он может удалиться, и тогда обращение к такому свойству приведет к крэшу (потому и unsafe). Это значение использовалось вместо weak, когда уже появился ARC, но нужно было еще поддерживать iOS 4.3. Сейчас его использование можно оправдать разве что скоростью работы (есть сведения, что магия weak свойств требует значительного времени, хотя, конечно, невооруженным глазом при нынешней производительности этого не заметишь), поэтому, особенно на первых порах, использовать его не стоит.


  • assign (соответствующая переменная должна быть с атрибутом __unsafe_unretained, но так как атрибуты владения есть только у типов попадающих под ARC, с которыми лучше использовать strong или weak, это значение вам вряд ли понадобится) — просто присвоение адреса. Без ARC является дефолтным значением атрибута владения. Его стоит применять к свойствам типов, не попадающих под действие ARC (к ним относятся примитивные типы и так называемые необъектные типы (non-object types) вроде CFTypeRef). Без ARC он также используется вместо weak для исключения retain cycle«ов для свойств, в которых хранится указатель на делегат объекта и им подобных.


Атрибут атомарности

  • atomic — это дефолтное значение для данного атрибута. Оно означает, что акцессор и мутатор будут сгенерированы таким образом, что при обращении к ним одновременно из разных потоков, они не будут выполняться одновременно (то есть все равно сперва один поток сделает свое дело — задаст или получит значение, и только после этого другой поток сможет заняться тем же). Из-за особенностей реализации у свойств с таким значением атрибута атомарности нельзя переопределять только один из методов доступа (уж если переопределяете, то переопределяйте оба, и сами заморочьтесь с защитой от одновременного выполнения в разных потоках). Не стоит путать атомарность операции с потокобезопасностью. К примеру, если вы в одном потоке получаете значение имени и фамилии из свойств объекта, а в другом — изменяете эти же значения, вполне может получиться так, что значение имени вы получите старое, а фамилии — уже измененное. Соответственно, применять стоит для свойств объектов, доступ к которым может осуществляться из многих потоков одновременно, и нужно спастись от получения каких-нибудь невалидных значений, но при необходимости обеспечить полноценную потокобезопасность, одного этого будет недостаточно. Кроме прочего стоит помнить, что методы доступа таких свойств работают медленнее, чем nonatomic, что, конечно, мелочи в масштабах вселенной, но все же копейка рубль бережет, поэтому там, где нет необходимости, лучше использовать nonatomic.


  • nonatomic — значение противоположное atomic — у свойств с таким значением атрибута атомарности методы доступа не обременены защитой от одновременного выполнения в разных потоках, поэтому выполняются быстрее. Это значение пригодно для большинства свойств, так как большинство объектов все-таки используются только в одном потоке, и нет смысла «обвешивать» их лишними фичами. В общем, для всех свойств, для которых не сможете объяснить, почему оно должно быть atomic, используйте nonatomic, и будет вам fast and easy and smart и просто праздник какой-то.


На этом повествование спешу закончить. Кому есть что добавить или с чем поспорить — милости просим в комменты.

© Habrahabr.ru