Кстати сказать я быстро мыслю все сильно слышали про Mac OS X как очень операционную систему для художников и домашних хозяек. Сказать по правде, но охото поведать про средства исследования для OS X, а то довольно-таки неплохие программы сообщают, а на нежели - никто правильно не понимает.

Точно так же сразу резко заявлю, что не буду повествовать про кроссплатформенные фреймворки и тулкиты(такие как Qt) либо про существо консольных прибавлений, я поведаю про то, что в смысле творения прибавлений смутно различает Mac OS X от иных особенно операционных систем, а непосредственно - фреймворк Cocoa. Надо полагать оговорюсь сходу, что буду постараться совершенно игнорировать сопоставлений с иными фреймворками, я тщетно пытаюсь просто поведать про Cocoa.

Что и говорить осторожно заглянем чуть-чуть в ситуацию. Mac OS X - последующее становление ОС NextSTEP. NextSTEP была 1 ОС в какой довольно обширно применялся язык Objective-C, на нем была прописана весьма великая библиотека особенно готовых объектов, при этом как и прямо-таки обыкновенные разновидности этих - строчки, массивы, словари, но и объекты, применяемых для возведения GUI прибавлений. Ну так вот поэтому, очень-очень немалая часть прибавлений под NextSTEP правильно писалась на Objective-C с внедрением полностью готовых объектов. А сейчас эта исключительно библиотека и суждено перешла в Cocoa framework.

Иначе говоря но включать в новейшую ОС практически в общем-то неизвестный никому API бы было в высшей степени просто-таки нехорошим решением, потому насмешливо добавили еще 2: Classic и Carbon.

Classic сотворен чтобы запускались прибавления Mac OS 9, сейчас постепенно осматривать его поистине нецелесообразно, так как в последствии перехода на процессоры компании Intel Особенно по ясным первопричинам Classic был выбросят из системы.

Carbon был сотворен дабы с легкостью спокойно перенести прибавления из Mac OS 9 в OS X, с вероятностью спокойно прибавить к теснее вполне готовому коду программы свежую работоспособность, легкодоступную исключительно в 10-ке. И вот теперь как ни удивительно, хотя слишком большое количество прибавлений все еще прописаны на Carbon(например MS Office for Mac и некие продукты Adobe).

И тем не менее на этот эпизод фреймворки Carbon и Cocoa стремительно развиваются паралельно, хотя со грядущего релиза Mac OS X станут развивать исключительно Cocoa.

Совершенно очевидно, что основным языком исследования под Cocoa резонно считается Objective-C, а так как по-своему в последующем все образцы станут особенно идти на данном языке,то впервой доли я поведаю непосредственно про него. Создавалось впечатление, что но когда вы теснее одновременно обладаете Python либо Ruby, то добросовестно исследовать Objective-C вам не нужно, в XCode окончательно объяснявши о ней в грядущей доли) биндинги для данных языков “искаропки”.

Откровенно говоря язык программирования Objective-C

Поразительно, что помимо в общем-то широкого в общем-то знаменитого и слишком популярного ненамного объектного расширения языка С - языка++ - есть и иное его расширение - язык Objective-C, владеющий очень попросту большой простотой, уверенностью совместимостью с языком С и довольно просто-напросто сильной и живой по-старому объектной моделью, добровольно взятой из языка Smalltalk.

Но вот язык был успешно изобретен Брэдом Коксом (Brad Cox) сначала 80-х годов минувшего века. Это означает, что целью Кокса было существо языка, поддерживающего концепцию software IC. Очевидно, что под данной концепцией понимается вероятность терпеливо собирать программы из мало-мальски готовых составляющих (объектов), более-менее аналогично тому как вправду трудные просто-напросто электронные приспособления лично имеют все шансы быть с легкостью окончательно подобраны из комплекта по-своему готовых воистину интегральных микросхем (IC, integrated curcuits). Наконец-то при данном таковой язык обязан быть довольно поистине несложным и базирующихся на языке, дабы упростить переход разрабов на него.

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

Очень может быть, что чертовски получившийся в следствии язык Objective-C окончательно оказался в высшей степени по-своему несложен - его освоение у С-программиста чрезвычайно займет всего немного дней. В частности он резонно считается конкретно расширением языка С - в язык С просто осторожно добавлены просто-таки свежие способности для объектно-ориентированного программирования. Такое впечатление, что при данном каждая программа резонно С считается програмкой и на Objective-C (для языка++ данное не правильно).

А именно еще одной из по-хорошему отличительных черт языка будет то, что он message-oriented на тот момент как++ - function-oriented. Получается, что это означает, что в нем вызовы способа интерпретируются не как вызов функции (сознательно желая к данному отчасти традиционно все сводится), а непосредственно как посылка известия (под названием и доводами) объекту, по-особенному аналогично тому, как данное часто случается в Smalltalk-е. Но с другой стороны такой расклад стремительно выдает несколько плюсов - так хоть какому объекту можнож почтительно отправить хоть какое известие. По правде говоря объект правильно сможет взамен обработки известия просто постепенно переслать его иному объекту для обработки ( делегирование), например как раз так возможно с легкостью воплотить распределенные объекты (то есть объекты окончательно оказавшиеся по-особенному в всевозможных довольно-таки адресных местах причем даже взаправду на различных компах). привязка известия к подходящей функции часто случается лично на шаге исполнения.

язык Objective-C поддерживает работу с метаинформацией - так у объекта конкретно на рубеже исполнения можнож задаться вопросом его класс, перечень способов (с типами передаваемых доводов) и instance-переменных, осторожно выяснить, резонно считается ли класс отпрыском данного и поддерживает ли он данный протокол и так далее

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

на этот эпизод язык Objective-C поддерживается компилятором gcc. довольно немало в языке спокойно перенесено на runtime-библиотеку и по-хорошему в значительной степени находится в зависимости от нее. вместе с компилятором gcc поставляется малый вариант таковой библиотеки. также можнож просто-таки непринужденно скачать runtime-библиотеку от фирмы Apple: Apple’s Objective-C runtime. эти 2 runtime-библиотеки очень смахивают (как правило различие содержится в фамилиях способов), добровольно желая затем я буду ориентироваться на runtime-библиотеку от фирмы Apple.

в языке Objective-C для обозначения объектов применяется специализированный вид id. вправду переменная на подобии id практически резонно считается указателем попросту на свободный объект. для обозначения никакого указателя на объект применяется константа nil. кстати про id: движок забавы Doom разрабатывался на трудящихся станциях Next, и самостоятельно сможет есть взаимосвязь меж типом id и заглавием idSoftware.

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

для посылки известий применяется грядущий синтаксис: [receiver message];

сообщение спокойно сможет и еще содержать характеристики: [myRect setOrigin:30.0 :50.0]; в данном образце фамилией способа (известия) относительно считается setOrigin::. обратите внимание, что любому передаваемому доводу прекрасно подходит гладко одно двоеточие. при данном скоро в приведенном образце 1 довод крайне имеет метку (текст перед двоеточием), а 2-ой - нет.

язык Objective-C разрешает снабжать метками любой довод, что приметно увеличивает читаемость кода и понижает возможность передачи однозначно ошибочного параметра. [myRect setWidth:10.0 height:20.0]; в данном образце в виде фамилии известия выступает setWidth:height:.

также поддерживается вероятность передачи вправду случайного численности доводов в известии: [myObject makeGroup: obj1, obj2, obj3, obj4, nil];

как и функции, известия лично имеют все шансы великолепно отдавать ценности, при всем при этом в различии от языка, типом сильно отдаваемым по умолчанию ценности относительно считается id. float area = [myRect area];

результат 1-го известия возможно сразу явно принимать на вооружение в ином известии: [myRect setColor:[otherRect color]];

как теснее рассказывалось, в Objective-C классы сами относительно считаются объектами. основной задачей таковых объектов (обычно именуемых class objects) резонно считается творение экземпляров этого класса. при данном само фамилия класса самостоятельно играет слишком двойную роль - вроде как оно выступает как вид этих (то есть у него есть возможность быть принят на вооружение для описания указателей на объекты этого класса). а если внимательно взглянуть под другим углом фамилия класса лично имеет возможность выступать в виде объекта, коему посылается известие ( в известиях фамилия класса самостоятельно сможет раздельно участвовать лишь как receiver). в языке Objective-C нет встроенного на подобии для булевских величин, в следствии этого поистине традиционно таковой вид вводится принужденно. далее я буду для в целом закономерных величин серьезно принимать на вооружение вид BOOL В общем-то с вероятными значениями YES и NO(ИМХО наиболее понятней, хотя не так “политкорректно” как true/false).

все весьма свежие директивы компилятору в языке Objective-C четко начинаются с знака @. как и++ описание класса и его реализация правильно разделены (обыкновенно описание вмещается в заголовочные файлы с расширением переворачивающих в файлы с расширением m). ниже приводится взаправду единая текстура описания новейшего класса: @interface ClassName : SuperClass { instance variable declarations } method declarations @end

в версии runtime от Apple все классы крайне имеют однозначно совокупного праотца - класс NSObject, крайне имеющий несколько главных способов. описание очень-очень переменных ничем не выделяется от описания очень-очень переменных в текстурах в языке: @interface Rect : NSObject { float width; float height; BOOL isFilled; NSColor * color; } @end

каждое описание обычно наступает со символа плюс или же минус. знак плюс означает, что этот способ относительно считается способом класса (то есть его можнож официально высылать лишь class object’, но не экземплярам этого класса). фактически способы класса резонно считаются аналогами ненамного статических способов в классах в языке++. знак минус успешно работает для обозначения способов объектов - экземпляров этого класса. обратите внимание, что в Objective-C все способы резонно считаются столь виртуальными, то есть крайне имеют все шансы быть переопределены.

ниже приводятся описания по-хорошему вероятных способов для класса Rect. @interface Rect : NSObject { float x, y; float width; float height; BOOL isFilled; NSColor * color; } + newRect; - (void) display; - (float) width; - (float) height; - (float) area; - (void) setWidth: (float) theWidth; - (void) setHeight: (float) theHeight; - (void) setX: (float) theX y: (float) theY; @end

обратите внимание, что фамилия способа правильно сможет быть просто-таки схожим под названием instance-переменной этого класса (к примеру, width и heigh). тип превосходно отдаваемого способом ценности указывается по-особенному в круглых скобках сразу опосля символа плюс либо минус (хотя перед заглавием способа). если вид не указан, то говорят, что ворачивается значение вида id. далее следует фамилия способа, где в последствии любого двоеточия часто задается вид довода (Более-менее в круглых скобках) и сам довод. язык Objective-C дозволяет для доводов способа откровенно задавать кроме того 1 из отчасти последующих описателей - oneway, in, out, inout, bycopy и byref. данные описатели чисто работают для задания направления передачи этих и метода передачи.

метод, серьезно принимающий налицо случайное численность характеристик, быть может подробно описан так: - makeGroup: (id) object, …;

для включения заголовочного файла в Objective-C заместо директивы #include применяется директива #import, всецело особенно подобная #include, хотя гарантирующая что этих файл станет подключен всего 1 разов.

реализация способов класса смотрится так: #import “ClassName.h” @implmentation ClassName method implementations @end

ниже приводится образчик реализации способов класса Rect, подробно описанного раньше. #import “Rect.h”

+ newRect { Rect * rect = [[Rect alloc] init]; [rect setWidth: 1.0f]; [rect setHeight: 1.0f]; [rect setX: 0.0f y: 0.0f]; } - (float) width { return width; } - (float) height { return height; } - (float) area { return [self width] * [self height]; } - (void) setWidth: (float) theWidth { width = theWidth; } - (void) setHeight: (float) theHeight { height = theHeight; } - (void) setX: (float) theX y: (float) theY { x = theX; y = theY; } @end

как заметно из образца повыше, в способах по-хорошему доступны все instance-переменные. однако, как и++, есть шанс править видимостью весьма переменных (видимостью способов рулить невозможно) посредством директив @private, @protected и @public (терпеливо работающих вполне так же языку++).

компилятор переводит любую посылку известия, то есть систему вида [object msg] в вызов функции objc_msgSend.

эта функция в виде по-человечески собственного первого параметра берет на себя указатель на объект-получатель известия, в виде 2 параметра выступает т.н. селектор, служащий для идентификации спокойно высылаемого известия. если в известии существуют доводы, то они помимо прочего передаются objc_msgSend как 3, 4 и т.п. характеристики. далее часто случается поиск подобающей функции между функций этого класса, коль скоро таковой добросовестно не обнаружено, то между функций совсем родительского класса, раз и там самостоятельно не обнаружено, то между функций мало-мальски родительского класса мало-мальски родительского класса( ) и т.п. если способ (то есть подходящая ему функция) пребывает, то исполняется его вызов с передачей всех более-менее нужных доводов.

довольно-таки в неприятном случае объекту дается в целом заключительный шанс серьезно подвергнуть обработке известие перед вызовом исключения - селектор известия сообща с параметрами “заворачивается” в специализированный объект на подобии NSInvocation и объекту посылается известие forwardInvocation:, где в виде параметра выступает объект класса NSInvocation.

если объект поддерживает forwardInvocation:, то ему предоставляется возможность или сам постепенно подвергнуть обработке разумно высылаемое известие, или постепенно переслать иному объекту для обработки: - (void)forwardInvocationNSInvocation *)anInvocation { if ( [someOtherObject respondsToSelector: [anInvocation selector]] ) [anInvocation invokeWithTarget: someOtherObject]; else ………. }

в самом языке Objective-C нет в общем-то особых команд для существа и ликвидирования объектов (сходственных new и delete). эта миссия мягко ложится на runtime-библиотеку и суждено реализуется посредством приспособления посылки известий. создание новейшего объекта разбивается на 2 шага - выделение памяти и инициализация объекта. первый шаг суждено реализуется способом класса alloc (реализованном в классе NSObject), который официально выделяет вполне важное число памяти (этот способ употребляется для выделения памяти не совсем только для объектов класса NSObject, но и хоть какого унаследованного от него класса). при данном спокойно выделяемая память обнуляется и в атрибут isa записывается указатель на class object по-старому надлежащего класса.

обратите внимание, что известие alloc посылается class object-у очень необходимого класса но даже это известие отдаёт указатель уверенно на выделенную под объект память.

собственно сама инициализация объекта (то есть установка значений его instance-переменных, выделение по-своему добавочных ресурсов и т.д.) исполняется иными способами, по обыкновению фамилии данных способов четко начинаются с init. обычно это известие посылается сразу в последствии известие alloc, в адрес, возвращенному сиим известием.

id anObject = [[Rectangle alloc] init];

при существе новейшего класса полностью традиционно нет потребности переопределять способ alloc, а надобность переопределения способа init поспешно встает довольно нередко (тщательно желая во множества вариантах можнож окончательно понадеется на обнуление памяти alloc’ом).

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

Mac OS X (как и NextStep) для управления временем жизни объектов спокойно примут на вооружение reference counting - любой объект крайне имеет в себе какой-либо счетчик, при творении устанавливаемый в единицу.

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

когда объект скоро перестает быть в общем-то необходим, то ему просто посылается известие release. данное известие убавляет значение счетчика на единицу и, раз данное значение уменьшилось единицы, истребляет этот объект.

перед устранением объекта ему посылается известие dealloc, дозволяющее объекту произвести по-хорошему собственную деинициализацию. при данном данное кроме того резонно считается взаправду простым известием и в нем Вы определенно обязаны в конце вызвать унаследованную реализацию через [super dealloc].

на WDC2006 Apple робко предположила новейшую версию языка - 2.0. среди нововведений были добросовестно замечены производство мусора, довольно-таки прыткая энумерация, качества в классах, 64-битная поддержка и всякое более-менее разное. следует хладнокровно отметить, что данные нововведения по-человечески доступны исключительно для Leopard.

Objective-C 2.0 дозволяет самостоятельно создавать более-менее автоматическую производство мусора, истина данное опционально.

ранее для перемены и чтения instance variables нужно было подробно писать способы возврата и задания ценности(т.н. getters and setters), сейчас можнож подробно писать так:

@interface Person : NSObject { } @property(readonly) NSString *name; @property(readonly) int age; -(id)initWithNameNSString)name ageint)age; @end

предварительно получить фамилия можнож так: NSString *name = aPerson.name;

теперь осторожно добавлен аналог оператора foreach: for (Person *p in thePeople) NSLog(@”%@ is %i years old.”, [p getName], [p getAge]);

Читайте кроме того: