Текст книги "Программирование на Objective-C 2.0"

Автор книги: Стивен Кочан

сообщить о нарушении

Текущая страница: 3 (всего у книги 32 страниц)

В общем виде секция @implementation имеет следующий формат. @implementation Имя-Нового-Класса Определения-методов; @end

Имя-Нового-Класса – то же самое имя, которое использовалось для данного класса в секции @interface. Можно использовать двоеточие в конце имени и затем имя родительского класса, как мы делали в секции @interface: @implementation Fraction: NSObject

Однако это не обязательно, и обычно не делается.

Часть Определения-методов секции @implementation содержит код для каждого метода, указанного в секции @interface. Аналогично секции @interface, определение каждого метода начинается с указания типа метода (для класса или экземпляра), типа возвращаемого значения, аргументов метода и их типов. Но вместо завершения строки символом «точка с запятой» следует код для этого метода, заключенный в фигурные скобки.

Рассмотрим секцию @implementation из программы 3.2. //– @implementation section – @implementation Fraction -(void) print { NSLog ("%i/%i", numerator, denominator); } -(void) setNumerator: (int) n { numerator = n; ) -(void) setDenominator: (int) d { denominator = d; } @end

В методе print используется NSLog для вывода значений переменных экземпляра numerator и denominator, numerator и denominator – это переменные экземпляра в объекте, который является получателем сообщения. Это важная концепция, и мы еще вернемся к ней.

Метод setNumerator: сохраняет значение целого аргумента, которому мы при-своили имя п, в переменной экземпляра numerator. Метод setDenominator: сохраняет значение аргумента d в переменной экземпляра denominator. 3.6. Секция program

Секция program содержит код для решения конкретной задачи, которая может включать много файлов. Как говорилось выше, наличие процедуры main является обязательным. В ней начинается выполнение программы. Ниже приводится секция program из программы 3.2. //– program section – int main (int argc, char *argv[]) { NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init]; Fraction *myFraction; // Create an instance of a Fraction (Создание экземпляра класса Fraction) myFraction = [Fraction alloc]; myFraction = [myFraction init]; // Set fraction to 1/3 (Задание значения дроби 1/3) [myFraction setNumerator: 1]; [myFraction setDenominator: 3]; // Display the fraction using the print method (Вывод дроби с помощью метода print) NSLog (@The value of myFraction is:"); [myFraction print]; [myFraction release]; [pool drain]; return 0; }

Внутри процедуры main вы определяете переменную с именем myFraction: Fraction *myFraction;

Здесь указывается, что myFraction является объектом типа Fraction, то есть myFraction используется для хранения значений из вашего нового класса Fraction. Звездочка (*) перед myFraction является обязательным элементом. Технически она обозначает, что myFraction является на самом деле ссылкой (или указателем – pointer) на Fraction. Мы рассмотрим ссылки позднее.

Теперь, когда у нас имеется объект для хранения дроби (Fraction), нужно создать саму дробь. myFraction = [Fraction alloc];

alloc – это сокращение от allocate (выделить). Вам нужно выделить пространство в памяти для новой дроби. С помощью этого выражения происходит отправка сообщения новому классу Fraction: [Fraction alloc]

Вы обращаетесь к классу Fraction для применения метода alloc, но вы не опре-деляли метод alloc. Он был унаследован из родительского класса. Эта тема рас-сматривается в главе 8.

Отправив классу сообщение alloc, вы получаете в ответ новый экземпляр этого класса. В программе 3.2 возвращаемое значение сохраняется внутри переменной myFraction. Метод alloc очищает все переменные экземпляра объекта. Затем вам нужно инициализировать объект после выделения памяти для него.

Это выполняет оператор: myFraction = [myFraction init];

Здесь используется метод init, который инициализирует экземпляр класса. Сообщение init отправляется в myFraction. Вам нужно инициализировать конк-ретный объект Fraction, поэтому вы отправляете сообщение не классу, а экземп-ляру этого класса.

Метод init возвращает также значение – инициализированный объект. Это возвращаемое значение сохраняется в переменной myFraction. Эта последовательность из двух строк (выделение памяти для нового экземпляра класса и последующая его инициализация) выполняется в Objective-C так часто, что два сообщения обычно объединяются: myFraction = [[Fraction alloc] init];

Сначала выполняется оценка внутреннего выражения: [Fraction alloc]

Результатом этого выражения является конкретный выделяемый элемент типа Fraction. Вместо сохранения результата выделения в переменной, как это было сделано выше, к нему непосредственно применяется метод init. Таким образом, здесь снова выделяется сначала новый элемент типа Fraction, и затем происходит его инициализация. Результат инициализации присваивается переменной myFraction.

Для сокращения записи выделение памяти и инициализация часто встра-иваются непосредственно в строку объявления: Fraction *myFraction = [[Fraction alloc] init];

Мы часто используем этот стиль в книге, поэтому важно, чтобы вы понимали его. Вы видели выше, как действует автоматически высвобождаемый пул (autorelease pool): NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];

Здесь сообщение alloc отправляется классу NSAutoreleasePool для запроса о создании нового экземпляра. Затем этому новому созданному объекту отправ-ляется сообщение init для его инициализации.Теперь, вернувшись к программе 3.2, вы можете задать значение дроби. // Set fraction to 1/3 [myFraction setNumerator: 1]; [myFraction setDenominator: 3];

В первом операторе выполняется отправка сообщения setNumerator: переменной myFraction. Для аргумента указывается значение 1, и управление передается методу setNumerator:, который был определен для класса Fraction. Система Objective – С «понимает», что это метод изданного класса, поскольку «знает», что myFraction является объектом из класса Fraction.

Внутри метода setNumerator: переданное значение 1 сохраняется в перемен-ной п. В единственной программной строке метода это значение сохраняется в переменной экземпляра numerator. Фактически вы присваиваете элементу numerator в myFraction значение 1.

Затем следует сообщение для обращения к методу setDenominator: в myFraction. Значение аргумента 3 присваивается переменной d внутри метода setDenominator:. Это значение затем сохраняется в переменной экземпляра denominator, что завершает присваивание значения 1/3 переменной myFraction. Теперь можно вывести на экран значение дроби. // display the fraction using the print method NSLog (@The value of myFraction is:"); [myFraction print];

В результате вызова NSLog выводится текст: The value of myFraction is: (Значение myFraction:)

В следующем выражении для сообщения вызывается метод print: [myFraction print];

Внутри метода print выполняется вывод значений переменных экземпляра numerator и denominator, разделенных наклонной чертой.

Следующее сообщение в программе освобождает память, которая исполь-зовалась для этого объекта Fraction: [myFraction release];

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

В системе выполнения программ (runtime) Apple обеспечивается механизм очистки памяти, который называется сборкой мусора (garbage collection), но луч-ше самому управлять использованием памяти, а не полагаться на этот автома-тизированный механизм.

Вы не можете полагаться на сборку мусора для тех платформ, где она не поддерживается, например, iPhone. У вас может создаться впечатление, что вам пришлось написать намного больше кода, чтобы сделать в программе 3.2 то же самое, что и в программе 3.1. Для данного простого примера это верно, но такой способ делает упрощает написание, поддержку и расширение больших и сложных программ. Вы поймете это позже.

В последнем примере этой главы показано, как работать с несколькими дро-бями. В программе 3.3 одной дроби присваивается значение 2/3, второй дроби – 3/7, и затем выполняется вывод обеих дробей. // Program to work with fractions – cont’d (Программа для работы с дробями – продолжение) #import //– @interface section – @interface Fraction: NSObject { int numerator; int denominator; } -(void) print; -(void) setNumerator: (int) n; -(void) setDenominator: (int) d; @end //– @implementation section – @implementation Fraction -(void) print { NSLog (@"%i/%i", numerator, denominator); } -(void) setNumerator: (int) n { numerator = n; ) -(void) setDenominator: (int) d { denominator = d; } @end //– program section – int main (int argc, char *argv[]) { NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init]; Fraction *frac1 = [[Fraction alloc] init]; Fraction *frac2 = [[Fraction alloc] init]; // Set 1st fraction to 2/3 (Задание 1 -й дроби 2/3) [frac setNumerator: 2]; [frac setDenominator: 3]; // Set 2nd fraction to 3/7 (Задание 2-й дроби 3/7) [frac2 setNumerator: 3]; [frac2 setDenominator: 7]; // Display the fractions (Вывод дробей) NSLog (@"First fraction is:"); [frac print]; NSLog (@"Second fraction is:"); [frac2 print]; [frac release]; [frac2 release]; [pool drain]; return 0; }

Вывод программы 3.3 First fraction is: (Первая дробь:) 2/3 Second fraction is: (Вторая дробь:) 3/7

Секции @interface и @implementation остались такими же, как в программе 3.2. В программе создаются два объекта типа Fraction, – frad и frac2, затем им присва-иваются соответственно значения 2/3 и 3/7. Когда метод setNumerator: применяется к frad, чтобы задать значение 2 для его числителя (numerator), выполняется присваивание значения 2 переменной экземпляра numerator. Аналогичным об-разом, когда для frac2 применяется тот же метод, чтобы задать значение 3 для его числителя, выполняется присваивание значения 3 его отдельной переменной экземпляра numerator. Новый объект получает свой собственный отдельный набор переменных экземпляра при каждом создании (рис. 3.2).

В зависимости от объекта, которому отправляется сообщение, происходит ссылка на соответствующие переменные экземпляра. В следующем примере выполняется ссылка на numerator объекта fraci, если внутри метода setNumerator: используется имя numerator: [trad setNumerator: 2];

Это происходит потому, что получателем сообщения является frac1.

Рис. 3.2. Уникальные переменные экземпляра 3.7. Доступ к переменным экземпляра и инкапсуляция данных

Мы увидели, каким образом методы, используемые для работы с дробями, вы-полняют доступ по имени к двум переменным экземпляра: numerator и denominator. Метод экземпляра всегда может выполнять непосредственный доступ к переменным экземпляра. Однако это не может делать метод класса, поскольку он применяется только к самому классу, а не к экземплярам этого класса. Но что делать, если нужно выполнять доступ к переменным экземпляра из какого-либо другого места, например, изнутри процедуры main? Это нельзя сделать напрямую, поскольку переменные экземпляра скрыты. Это еще одна ключевая концепция, которая называется инкапсуляцией данных (data encapsulation). Это позволяет расширять и изменять определения класса, не заботясь о том, что пользователи данного класса будут работать с внутренними деталями класса. Инкапсуляция данных обеспечивает необходимый уровень изоляции между программистом и разработчиком класса.

Вы можете выполнять доступ к свои переменным экземпляра, написав спе-циальные методы для считывания их значений. Например, можно создать два новых метода (numerator и denominator) для доступа к соответствующим переменным экземпляра Fraction, который является получателем сообщения. Результатом будет возвращаемое целое значение. Ниже приводятся объявления для двух новых методов: -(int) numerator; -(int) denominator;

Их определения: -(int) numerator { return numerator; } -(int) denominator { return denominator; }

Имена методов и переменных экземпляра, к которым они выполняют доступ, совпадают. Это распространенная практика. В программе 3.4 выполняется проверка этих методов. // Program to access instance variables – cont’d (Программа доступа к переменным экземпляра – продолжение) #import //– @interface section – @interface Fraction: NSObject { int numerator; int denominator; } -(void) print; -(void) setNumerator: (int) n; -(void) setDenominator: (int) d; -(int) numerator; -(int) denominator; @end //– @implementation section – @implementation Fraction -(void) print { NSLog (@»%i/%i», numerator, denominator); } -(void) setNumerator: (int) n { numerator = n; } -(void) setDenominator: (int) d { denominator = d; } -(int) numerator { return numerator; } -(int) denominator { return denominator; } @end //– program section – int main (int argc, char *argv[]) { NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init]; Fraction *myFraction = [[Fraction alloc] init]; // Set fraction to 1 /3 [myFraction setNumerator: 1]; [myFraction setDenominator: 3]; // Display the fraction using our two new methods NSLog (@The value of myFraction is: %i/%i", [myFraction numerator], [myFraction denominator]); [myFraction release]; [pool drain]; return 0; }

Вывод программы 3.4 The value of myFraction is 1/3 (Значение myFraction 1/3)

Оператор NSLog выводит результаты отправки двух сообщений экземпляру myFraction: первого – для считывания значения его переменной numerator, второго – для считывания значения denominator. NSLog (@"The value of myFraction is: %i/%i", [myFraction numerator], [myFraction denominator]);

Методы, которые задают значения переменных экземпляра, называют ус-тановщиками (setters), а методы, которые используются для считывания значе-ний переменных экземпляра, называются получателями (getters). Для класса Fraction методы setNumerator: и setDenominator: являются установщиками, a numerator и denominator являются получателями.

Примечание. Вскоре вы познакомитесь с удобным средством Objective-C 2.0, которое позволяет автоматически создавать методы-установщики и методы– получатели.

Мы должны указать, что метод с именем new объединяет действия методов alloc и init. Поэтому следующую строку можно использовать для выделения па-мяти и инициализации нового объекта Fraction: Упражнения

Какие из следующих имен не являются допустимыми? Почему? Int playNextSong 6_05 _calloc Хх alphaBetaRoutine clearScreen_1312 z Reinitialize _ A$

По аналогии с автомобилем, рассмотрите объект, который вы используете каждый день. Определите класс для этого объекта и напишите пять действий для этого объекта.

Для списка из упражнения 2 используйте следующий синтаксис, чтобы переписать ваш список в указанном формате: [экземпляр метод];

Предположим, что у вас, помимо автомобиля, есть лодка и мотоцикл. На-пишите список действий, которые вы можете выполнять с каждым из них. Есть ли какое-то перекрытие между этими действиями?

В соответствии с вопросом 4 предположим, что у вас есть класс с именем Vehicle (Средство передвижения) и объект с именем myVehicle, которым может быть Саг (Автомобиль), Motorcycle (Мотоцикл) или Boat (Лодка). Предположим, вы написали следующее: [myVehicle prep]; [myVehicle getGas]; [myVehicle service]; Видите ли вы преимущества в применении действия к объекту, который относится к одному из нескольких классов?

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

Определите класс с именем XYPoint для декартовых координат (х, у), где х и у – целые значения. Определите методы, позволяющие по отдельности задавать координаты точки и считывать их значения. Напишите программу на Objective-C, чтобы реализовать этот новый класс.

Глава 4. Типы данных и выражения

В этой главе мы рассмотрим базовые типы данных и основные правила форми-рования арифметических выражений в Objective-C. 4.1. Типы данных и константы

Вы уже видели, как в Objective-C используется один из основных типов данных – int. Переменную, объявленную с типом int, можно использовать только для хра-нения целых значений.

В языке программирования Objective-C имеются три основных типа данных: float, double и char. Переменную, которая объявлена с типом float, можно ис-пользовать для хранения чисел с плавающей точкой (то есть значений, имеющих дробную часть). Тип double тоже хранит числа с плавающей точкой, но с двойной точностью. Тип данных char можно использовать для хранения одного символа, например, буквы «а», цифры «6», знака «;» (подробнее об этом см. ниже).

В Objective-C любое число, символ или строка символов называется констан-той (constant). Например, число 58 является целым значением-константой. Строка @"Programming in Objective-C is fun.n" – это пример объекта-константы со строкой символов. Выражение, содержащее только значения-константы, называется выражением-константой, или константным выражением (constant expression). Следующее выражение является константным, поскольку каждый из членов этого выражения является константой: 128 + 7-17

Но если i объявлена как переменная целого типа, то это выражение уже не будет константным: 128 + 7-i Тип int

В Objective-C целая константа состоит из одной или нескольких цифр. Знак «ми-нус» перед цифрами указывает, что это отрицательное значение. 158, -10 и 0 – примеры целых констант. Между цифрами не допускаются пробелы, и значения между тройками цифр нельзя разделять запятыми. (То есть число 12,000 должно быть записано как 12000.)

В Objective-C имеется два специальных формата записи целых констант с основанием, отличным от 10. Если первая цифра целого значения равна 0, это значение считается восьмеричным, octal (по основанию 8). В этом случае остальные цифры должны быть допустимыми восьмеричными цифрами от 0 до 7. Например, чтобы представить в Objective-C восьмеричное значение 50 (эквива-лентное десятичному значению 40), используется форма записи 050. Восьмеричная константа 0177 эквивалентна десятичному значению 127(1 x64 + 7x8 + 7). Целое значение можно вывести на экран в восьмеричной записи, вызвав NSLog и указавы символы формата %о в строке форматирования. Значение выводится в восьмеричной записи без ведущего нуля. Символы формата %#о выводят ведущий нуль перед восьмеричным значением.

Если перед целой константой ставятся 0 и буква х (прописная или строчная), значение считается шестнадцатеричным (по основанию 16). После буквы х следуют цифры шестнадцатеричного значения (это цифры 0-9 и буквы a-f (или A-F). Буквы представляют, соответственно, десятичные числа от 10 до 15. На-пример, чтобы присвоить шестнадцатеричное значение FFEF0D целой пере-менной с именем rgbColor, можно использовать оператор: rgbColor = OxFFEFOD;

Символы форматирования %х выводят значение в шестнадцатеричном фор-мате без ведущих символов Ох и с использованием строчных букв a-f. Чтобы вывести значение с ведущими символами Ох, нужно использовать символы фор-матирования %#х: NSLog ("Color is %#xn", rgbColor);

Для вывода ведущего символа х и шестнадцатеричных цифр прописными буквами в символах форматирования ставится прописная буква X: %Х или %#Х.

Каждое значение, будь то символ, целое число или число с плавающей точ-кой, имеет связанный с ним диапазон значений. Этот диапазон связан с коли-чеством памяти, выделяемой для хранения определенного типа данных. Обычно он зависит от компьютера, на котором выполняется работа, и поэтому называется реализацией или машинно-зависимым диапазоном (implementation или machine dependent). Так, целое значение может занимать на вашем компьютере 32 или 64 бита.

Никогда не пишите программы, в которых предполагается определенный размер типов данных. Для каждого базового типа данных гарантируются опре-деленные размеры памяти, например, для целого значения отводится не менее 32 бит памяти. Однако на некоторых машинах это не выполняется (см. таблицу В.З в приложении В). Тип float

Для хранения значений, содержащих знаки после запятой (точки), можно ис-пользовать переменные с типом float. Признаком константы с плавающей точкой является присутствие десятичной точки. Можно не указывать цифры до десятичной точки или после нее, но, очевидно, нельзя не указывать одновре-менно обе составляющие. 3., 125.8 и -.0001 являются примерами констант с плавающей точкой. В NSLog для вывода значения с плавающей точкой используются символы формата %f.

Константы с плавающей точкой можно записывать в виде так называемого экспоненциального представления (scientific notation). 1.7е4 – это значение с плавающей точкой для 1.7 х 104. Значение до буквы е называется мантиссой (mantissa), а значение после е называется порядком (exponent). Порядок, который может быть дополнительно снабжен знаком «плюс» или «минус», представляет степень числа 10 для умножения на мантиссу. Например, в константе 2.25е-3 значение 2.25 – это мантисса, а -3 – порядок. Эта константа представляет значение 2.25 х 10-3, или 0.00225. Букву е, которая отделяет мантиссу от порядка, можно записывать и как прописную, и как строчную букву.

Чтобы вывести значение в экспоненциальном представлении, в строке фор-мата NSLog должны быть заданы символы форматирования %е. Если исполь-зовать символы формата %g, то процедура NSLog сама определит, как выводить значение с плавающей точкой: в обычном форме записи с плавающей точкой или в экспоненциальном представлении. Решение основывается на значении порядка: если он меньше -4 или больше 5, то используется формат %е (экспоненциальное представление), если нет – используется формат %f.

Шестнадцатеричная константа с плавающей точкой содержит ведущие символы Ох или 0Х, после которых следует одна или несколько шестнадцатеричных цифр, затем р или Р, после чего следует двоичный порядок. Например, ОхО.ЗрЮ представляет значение 3/16 х 210 = 192. Тип double

Тип double аналогичен типу float. Он используется, если диапазон, предоставляе-мый переменной типа float, не дает достаточной точности. В переменных, кото-рые объявлены с типом double, можно сохранять примерно вдвое больше цифр, чем с типом float. На большинстве компьютеров для значений типа double ис-пользуются 64 бита.

Если не указано особо, то компилятор Objective-C обрабатывает все кон-станты с плавающей точкой как значения типа double. Чтобы явно задать кон-станту типа float, нужно добавить f или F в конце числа, например, 12.5L

Чтобы вывести значение типа @@ double, можно использовать символы формата %f, %е или %д, как и для значений типа float. Тип char

Переменную типа char можно использовать для хранения одного символа. Чтобы задать символ-константу, нужно заключить символ в апострофы, например, 'а', и '0'. Не следует путать символ-константу с символьной строкой в стиле С, которая содержит любое число символов, заключенных в кавычки. Строка символов, заключенная в кавычки, перед которой поставлен символ – это объект-строка типа NSString.

Примечание. В приложении В описываются методы сохранения символов из расширенных наборов с помощью специальных escape-последовательностей, уникальных символов и так называемых «широких» символов.

Символ-константа 'n' (символ новой строки) является допустимым симво-лом-константой. Обратный слэш (обратная наклонная черта) – это специальный символ в системе Objective-C, который не учитывается как отдельный символ. Компилятор Objective-C интерпретирует 'n' как один символ. Имеются и другие специальные символы, которые инициируются с помощью обратного слэша. Полный список приводится в приложении В. Для вывода значения переменной типа char можно использовать символы формата %с при вызове NSLog. В программе 4.1 используются базовые типы данных Objective-C. #import int main (int argc, char *argv[]) { NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init]; int integerVar = 100; float floatingVar = 331.79; double doubleVar = 8.44e+11; char charVar = 'W'; NSLog (@"integerVar = %i", integerVar); NSLog (@"floatingVar = %f", floatingVar); NSLog (@"doubleVar = %e", doubleVar); NSLog (@"doubleVar = %g", doubleVar); NSLog (@"charVar = %c", charVar); [pool drain]; return 0; }

Вывод программы 4.1 integerVar = 100 floatingVar = 331.790009 doubleVar = 8.440000e+11 doubleVar = 8.44e+11 charVar = 'W'

Во второй строке вывода значение 331.79, присвоенное переменной floatingVar, выводится как 331.790009. Причиной этой неточности является внутреннее представление чисел в компьютере. С таким же типом неточности вы сталкиваетесь при работе с числами на своем калькуляторе. Если разделить 1 на 3 на калькуляторе, в результате получится .33333333 (в конце, возможно, будет еще несколько троек). Эта строка является аппроксимацией одной трети калькулятором. Теоретически число троек бесконечно, но калькулятор может содержать столько цифр, сколько соответствует внутренней точности устройства. Тот же тип неточности возникает и здесь: определенные значения с плавающей точкой не могут быть точно представлены в памяти компьютера. Квалификаторы: long, long long, short, unsigned и signed

Если квалификатор long помещен непосредственно перед объявлением int, то соответствующая целая переменная на некоторых компьютерах имеет расши-ренный диапазон. Пример объявления long int: long int factorial;

Это объявление целой переменной factorial типа long. Как и в случае перемен-ных типа float и double, конкретная точность переменной типа long зависит от компьютерной системы. Во многих системах int и long int имеют одинаковый диапазон и могут использоваться для хранения целых значений до 32 бит (231 – 1, или 2147483647).

Значение константы типа long int формируется путем добавления буквы L (прописной или строчной) в конец целой константы. Между числом и буквой L не допускаются никакие пробелы. Ниже приводится пример объявления переменной numberOfPoints типа long int с начальным значением 131071100: long int numberOfPoints = 131071100L;

Чтобы вывести значение типа long int с помощью NSLog, перед символами форматирования i, о и х в качестве модификатора ставится буква I. Это означает, что символы форматирования %li выводят значения типа long int в десятичном формате, символы %1о – в восьмеричном формате, символы %1х – в шестнадцатеричном формате.

Пример применения типа данных long long: long long int maxAllowedStorage;

Указанная переменная будет иметь заданную увеличенную точность – не менее 64 бит. Для вывода целых значений типа long long вместо одной буквы I в строке NSLog используются две буквы I, как в "%Ш".

Квалификатор long разрешается также использовать перед типом double, например: long double US_deficit_2004;

Константа типа long double записывается в виде константы с плавающей точ-кой с добавлением в конце I или L, например: 1.234e+7L

Чтобы вывести значение типа long double, нужно указать модификатор L %Lf выводит значение типа long double с десятичной точкой, %Le выводит значение в экспоненциальном представлении, при %Lg процедура NSLog выбирает между %Lf и %Le.

Квалификатор short, помещенный перед объявлением int, указывает компи-лятору Objective-C, что определенная переменная используется для хранения относительно небольших целых значений. Переменные типа short экономят память. Это существенно, если программа использует большой объем памяти и количество доступной памяти ограничено.

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

В Objective-C не существует способа записать константу типа short int. Чтобы вывести переменную типа short int, нужно поместить букву h перед любым из символов преобразования в целое значение: %hi, %ho или %hx. Для отображения значений short int можно также использовать любой из символов преобразования в целое значение, поскольку эти символы можно преобразовать в целые значения, когда они передаются в процедуру NSLog как аргументы.

Квалификатор, который можно помещать перед переменной типа int, при-меняется для переменной, которая должна содержать только положительные числа. Это квалификатор unsigned. unsigned int counter;

Этот квалификатор расширяет диапазон значений целой переменной.

Константа типа unsigned int формируется путем добавления и ИЛИ U после кон-станты. OxOOffU

Для целой константы можно сочетать и (ИЛИ U) и I (или L). Например, в следующем случае компилятор будет интерпретировать константу 20000 как unsigned long. 20000UL

Целая константа, которая не заканчивается буквами u, U, I ИЛИ L и слишком велика, чтобы уместиться в обычный размер типа int, интерпретируется компи-лятором как unsigned int. Если она слишком велика, чтобы уместиться в unsigned int, то компилятор обрабатывает ее как long int. Если она не умещается даже в long int, компилятор обрабатывает ее как unsigned long int.

При объявлении переменных с типом long int, short int или unsigned int вы можете опустить ключевое слово int. Переменную counter типа unsigned int можно объявить следующим образом: unsigned counter;

Переменные типа char также можно объявлять как unsigned.

Квалификатор signed позволяет явно указать компилятору, что определенная переменная содержит значения со знаком. В основном его используют перед объявлением char. Подробное описание этого квалификатора выходит за рамки этой книги. Тип id

Тип данных id используется для хранения объекта любого типа. Его можно на-зывать обобщенным типом объекта. Ниже объявляется переменная number с типом id. id number;

Можно объявлять методы, которые возвращают значения типа id. -(id) newObject: (int) type;

Здесь объявляется метод экземпляра с именем newObject, который принимает один целый аргумент с именем type и возвращает значение типа id. id – это тип по умолчанию для типа возвращаемого значения и типа аргумента. Ниже приводится объявление метода класса, который возвращает значение типа id. +alloclnit;