Objective-C Hızlı Kılavuzu
Objective-C, Small Talk programlama dilinin özelliklerini nesne yönelimli bir dil haline getirerek C Programlama dilinin üzerine geliştirilen genel amaçlı bir dildir. Öncelikle iOS ve Mac OS X işletim sistemlerinin yanı sıra uygulamalarının geliştirilmesinde kullanılır.
Başlangıçta Objective-C, iOS ve Mac OS X için Apple tarafından devralındığı NeXTSTEP OS için NeXT tarafından geliştirildi.
Nesne yönelimli programlama
Nesne yönelimli geliştirmenin dört sütunu dahil olmak üzere nesne yönelimli programlamayı tam olarak destekler -
- Encapsulation
- Veri gizleme
- Inheritance
- Polymorphism
Örnek Kod
#import <Foundation/Foundation.h>
int main (int argc, const char * argv[]) {
NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];
NSLog (@"hello world");
[pool drain];
return 0;
}
Temel Çerçeve
Temel Çerçeve, çok sayıda özellik sağlar ve aşağıda listelenmiştir.
NSArray, NSDictionary, NSSet ve benzeri genişletilmiş veri türlerinin bir listesini içerir.
Dosyaları, dizeleri vb. İşleyen zengin bir işlevler kümesinden oluşur.
URL işleme, tarih biçimlendirme, veri işleme, hata işleme gibi yardımcı programlar sağlar.
Öğrenme Hedefi-C
Objective-C'yi öğrenirken yapılacak en önemli şey, kavramlara odaklanmak ve dilin teknik detaylarında kaybolmamaktır.
Bir programlama dili öğrenmenin amacı daha iyi bir programcı olmaktır; yani, yeni sistemlerin tasarlanması ve uygulanmasında ve eski sistemlerin korunmasında daha etkili olmak.
Objective-C Kullanımı
Objective-C, daha önce de belirtildiği gibi, iOS ve Mac OS X'te kullanılmaktadır. Geniş bir iOS kullanıcı tabanına ve büyük ölçüde artan Mac OS X kullanıcılarına sahiptir. Ve Apple önce kaliteye odaklandığından ve Objective-C'yi öğrenmeye başlayanlar için harika.
Yerel Ortam Kurulumu
Ortamınızı hala Objective-C programlama dili için kurmaya istekli iseniz, bilgisayarınızda bulunan aşağıdaki iki yazılıma ihtiyacınız vardır, (a) Metin Düzenleyici ve (b) GCC Derleyici.
Metin düzeltici
Bu, programınızı yazmak için kullanılacaktır. Birkaç düzenleyicinin örnekleri arasında Windows Not Defteri, İşletim Sistemi Düzenleme komutu, Kısa, Epsilon, EMACS ve vim veya vi bulunur.
Metin düzenleyicinin adı ve sürümü farklı işletim sistemlerine göre değişebilir. Örneğin, Not Defteri Windows'ta kullanılacak ve vim veya vi, Linux veya UNIX'in yanı sıra Windows'ta da kullanılabilir.
Düzenleyicinizle oluşturduğunuz dosyalara kaynak dosyalar denir ve program kaynak kodunu içerir. Objective-C programlarının kaynak dosyaları genellikle ".m".
Programlamanıza başlamadan önce, bir metin düzenleyiciniz olduğundan ve bir bilgisayar programı yazmak, onu bir dosyaya kaydetmek, derlemek ve sonunda çalıştırmak için yeterli deneyime sahip olduğunuzdan emin olun.
GCC Derleyicisi
Kaynak dosyada yazılan kaynak kodu, programınız için okunabilir kaynaktır. Makine diline dönüşmesi için "derlenmesi" gerekir, böylece CPU'nuz programı verilen talimatlara göre gerçekten çalıştırabilir.
Bu GCC derleyicisi, kaynak kodunuzu son çalıştırılabilir programa derlemek için kullanılacaktır. Bir programlama dili derleyicisi hakkında temel bilgiye sahip olduğunuzu varsayıyorum.
GCC derleyicisi çeşitli platformlarda ücretsiz olarak mevcuttur ve çeşitli platformlarda kurulum prosedürü aşağıda açıklanmıştır.
UNIX / Linux üzerine kurulum
İlk adım, gcc Objective-C paketi ile birlikte gcc'yi kurmaktır. Bu, -
$ su - $ yum install gcc
$ yum install gcc-objc
Bir sonraki adım, aşağıdaki komutu kullanarak paket bağımlılıklarını kurmaktır -
$ yum install make libpng libpng-devel libtiff libtiff-devel libobjc
libxml2 libxml2-devel libX11-devel libXt-devel libjpeg libjpeg-devel
Objective-C'nin tüm özelliklerini elde etmek için GNUStep'i indirin ve kurun. Bu, paketi şuradan indirerek yapılabilir.http://main.gnustep.org/resources/downloads.php.
Şimdi, indirilen klasöre geçmemiz ve dosyayı -
$ tar xvfz gnustep-startup-
.tar.gz
Şimdi, kullanılarak oluşturulan gnustep-startup klasörüne geçmemiz gerekiyor -
$ cd gnustep-startup-<version>
Ardından, derleme sürecini yapılandırmamız gerekiyor -
$ ./configure
Sonra, inşa edebiliriz -
$ make
Sonunda çevreyi -
$ . /usr/GNUstep/System/Library/Makefiles/GNUstep.sh
Aşağıdaki gibi bir merhabaWorld.m Objective-C sahibiz -
#import <Foundation/Foundation.h>
int main (int argc, const char * argv[]) {
NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];
NSLog (@"hello world");
[pool drain];
return 0;
}
Şimdi, cd kullanarak dosyayı içeren klasöre geçerek ve ardından aşağıdaki adımları kullanarak merhabaWorld.m diyen bir Objective-C dosyasını derleyip çalıştırabiliriz -
$ gcc `gnustep-config --objc-flags`
-L/usr/GNUstep/Local/Library/Libraries
-lgnustep-base helloWorld.m -o helloWorld
$ ./helloWorld
Aşağıdaki çıktıyı görebiliriz -
2013-09-07 10:48:39.772 tutorialsPoint[12906] hello world
Mac OS üzerine kurulum
Mac OS X kullanıyorsanız, GCC'yi edinmenin en kolay yolu, Xcode geliştirme ortamını Apple'ın web sitesinden indirmek ve basit kurulum talimatlarını izlemektir. Xcode'u kurduktan sonra, C / C ++ için GNU derleyicisini kullanabileceksiniz.
Xcode şu anda developer.apple.com/technologies/tools/ adresinde mevcuttur .
Windows üzerine kurulum
Windows üzerinde Objective-C programını çalıştırmak için MinGW ve GNUStep Core kurmamız gerekiyor. Her ikisi de şu adreste mevcuttur:https://www.gnu.org/software/gnustep/windows/installer.html.
Öncelikle MSYS / MinGW Sistem paketini kurmamız gerekiyor. Sonra GNUstep Core paketini kurmamız gerekiyor. Her ikisi de kendi kendini açıklayan bir Windows yükleyici sağlar.
Ardından, Başlat -> Tüm Programlar -> GNUstep -> Kabuk'u seçerek Objective-C ve GNUstep'i kullanın.
HelloWorld.m içeren klasöre geçin
Programı kullanarak derleyebiliriz -
$ gcc `gnustep-config --objc-flags`
-L /GNUstep/System/Library/Libraries hello.m -o hello -lgnustep-base -lobjc
Programı kullanarak çalıştırabiliriz -
./hello.exe
Aşağıdaki çıktıyı alıyoruz -
2013-09-07 10:48:39.772 tutorialsPoint[1200] hello world
Objective-C programlama dilinin temel yapı taşlarını incelemeden önce, onu gelecek bölümlerde referans olarak alabilmemiz için minimum bir Objective-C program yapısına bakalım.
Objective-C Merhaba Dünya Örneği
Bir Objective-C programı temel olarak aşağıdaki bölümlerden oluşur -
- Önişlemci Komutları
- Interface
- Implementation
- Method
- Variables
- İfadeler ve İfadeler
- Comments
"Merhaba Dünya" kelimesini basacak basit bir koda bakalım -
#import <Foundation/Foundation.h>
@interface SampleClass:NSObject
- (void)sampleMethod;
@end
@implementation SampleClass
- (void)sampleMethod {
NSLog(@"Hello, World! \n");
}
@end
int main() {
/* my first program in Objective-C */
SampleClass *sampleClass = [[SampleClass alloc]init];
[sampleClass sampleMethod];
return 0;
}
Yukarıdaki programın çeşitli bölümlerine bakalım -
#İmport <Foundation / Foundation.h> programının ilk satırı , bir Objective-C derleyicisine gerçek derlemeye gitmeden önce Foundation.h dosyasını dahil etmesini söyleyen bir önişlemci komutudur.
Sonraki satır @interface SampleClass: NSObject , bir arayüzün nasıl oluşturulacağını gösterir. Tüm nesnelerin temel sınıfı olan NSObject'i miras alır.
Sonraki satır - (void) sampleMethod; bir yöntemin nasıl beyan edileceğini gösterir.
Bir sonraki @end satırı , bir arayüzün sonunu gösterir.
Sonraki satır @ uygulama SampleClass , SampleClass arabiriminin nasıl uygulanacağını gösterir.
Sonraki satır - (void) sampleMethod {} , sampleMethod'un uygulanmasını gösterir.
Sonraki satır @end bir uygulamanın sonunu gösterir.
Sonraki satır int main () , program yürütmenin başladığı ana işlevdir.
Sonraki satır /*...*/ derleyici tarafından göz ardı edilecek ve programa ek yorumlar eklemek için konulmuştur. Bu tür satırlara programda yorumlar denir.
Sonraki satır NSLog (...) , Objective-C'de bulunan ve "Hello, World!" Mesajına neden olan başka bir işlevdir. ekranda görüntülenecek.
Sonraki satır return 0; main () işlevini sonlandırır ve 0 değerini döndürür.
Objective-C Programını Derleyin ve Yürütün
Şimdi programı derleyip çalıştırdığımızda aşağıdaki sonucu alacağız.
2017-10-06 07:48:32.020 demo[65832] Hello, World!
Objective-C programının temel yapısını gördünüz, bu nedenle Objective-C programlama dilinin diğer temel yapı taşlarını anlamak kolay olacak.
Objective-C'deki Jetonlar
Bir Objective-C programı çeşitli belirteçlerden oluşur ve bir simge, bir anahtar sözcük, bir tanımlayıcı, bir sabit, bir dizge değişmezi veya bir semboldür. Örneğin, aşağıdaki Objective-C ifadesi altı simgeden oluşur -
NSLog(@"Hello, World! \n");
Bireysel belirteçler -
NSLog
@
(
"Hello, World! \n"
)
;
Noktalı virgül;
Objective-C programında noktalı virgül bir ifade sonlandırıcıdır. Yani, her bir ifadenin bir noktalı virgül ile bitmesi gerekir. Bir mantıksal varlığın sonunu gösterir.
Örneğin, iki farklı ifade aşağıdadır -
NSLog(@"Hello, World! \n");
return 0;
Yorumlar
Yorumlar, Objective-C programınızdaki yardım metni gibidir ve derleyici tarafından yok sayılır. / * İle başlarlar ve aşağıda gösterildiği gibi * / karakterleriyle sonlanırlar -
/* my first program in Objective-C */
Yorumlarda yorumlarınız olamaz ve bunlar bir dize veya karakter değişmezleri içinde yer almazlar.
Tanımlayıcılar
Bir Objective-C tanımlayıcısı, bir değişkeni, işlevi veya diğer herhangi bir kullanıcı tanımlı öğeyi tanımlamak için kullanılan bir addır. Tanımlayıcı, A'dan Z'ye veya a'dan z'ye veya alt çizgi _ ile başlar ve ardından sıfır veya daha fazla harf, alt çizgi ve rakam (0-9) gelir.
Objective-C, tanımlayıcılar içinde @, $ ve% gibi noktalama karakterlerine izin vermez. Objective-C bircase-sensitiveProgramlama dili. Dolayısıyla, İnsan gücü ve insan gücü , Objective-C'de iki farklı tanımlayıcıdır. İşte kabul edilebilir tanımlayıcılara bazı örnekler -
mohd zara abc move_name a_123
myname50 _temp j a23b9 retVal
Anahtar kelimeler
Aşağıdaki liste, Objective-C'deki ayrılmış sözcüklerden birkaçını göstermektedir. Bu ayrılmış sözcükler, sabit ya da değişken ya da başka herhangi bir tanımlayıcı isim olarak kullanılamaz.
Oto | Başka | uzun | değiştirmek |
kırmak | Sıralama | Kayıt ol | typedef |
durum | dış | dönüş | Birlik |
kömür | yüzen | kısa | imzasız |
sabit | için | imzalı | geçersiz |
devam et | git | boyutu | uçucu |
varsayılan | Eğer | statik | süre |
yapmak | int | yapı | _Paketli |
çift | protokol | arayüz | uygulama |
NSObject | NSInteger | NSNumber | CGFloat |
Emlak | atomik olmayan; | muhafaza etmek | kuvvetli |
güçsüz | güvensiz_ tutulmamış; | okuma yazma | Sadece oku |
Objective-C'deki boşluk
Yalnızca beyaz boşluk içeren, muhtemelen bir açıklama içeren bir satır boş satır olarak bilinir ve bir Objective-C derleyicisi bunu tamamen yok sayar.
Boşluk, Objective-C'de boşlukları, sekmeleri, yeni satır karakterlerini ve yorumları tanımlamak için kullanılan terimdir. Boşluk, bir ifadenin bir bölümünü diğerinden ayırır ve derleyicinin, bir ifadedeki int gibi bir öğenin nerede bittiğini ve bir sonraki öğenin nerede başladığını belirlemesini sağlar. Bu nedenle, aşağıdaki ifadede -
int age;
Derleyicinin bunları ayırt edebilmesi için int ve age arasında en az bir boşluk karakteri (genellikle boşluk) olmalıdır. Öte yandan aşağıdaki açıklamada,
fruit = apples + oranges; // get the total fruit
Meyve ve = arasında veya = ile elma arasında boşluk karakteri gerekmez, ancak okunabilirlik amacıyla dilerseniz bazılarını dahil etmekte özgürsünüz.
Objective-C programlama dilinde, veri türleri, farklı türlerdeki değişkenleri veya işlevleri bildirmek için kullanılan kapsamlı bir sistemi ifade eder. Bir değişkenin tipi, depoda ne kadar yer kapladığını ve depolanan bit deseninin nasıl yorumlandığını belirler.
Objective-C'deki türler şu şekilde sınıflandırılabilir:
Sr.No. | Türler ve Açıklama |
---|---|
1 | Basic Types − Aritmetik türlerdir ve iki türden oluşur: (a) tam sayı türleri ve (b) kayan nokta türleri. |
2 | Enumerated types − Yine aritmetik türlerdir ve program boyunca yalnızca belirli ayrık tam sayı değerlerine atanabilen değişkenleri tanımlamak için kullanılırlar. |
3 | The type void − Tür belirleyicisi void , hiçbir değerin mevcut olmadığını gösterir. |
4 | Derived types − Bunlar arasında (a) İşaretçi türleri, (b) Dizi türleri, (c) Yapı türleri, (d) Birleşim türleri ve (e) İşlev türleri bulunur. |
Dizi türleri ve yapı türleri topluca toplu türler olarak adlandırılır. Bir işlevin türü, işlevin döndürdüğü değerin türünü belirtir. Aşağıdaki bölümde temel türleri göreceğiz, diğer bölümlerde ise diğer türler ele alınacaktır.
Tamsayı Türleri
Aşağıdaki tablo, depolama boyutları ve değer aralıklarıyla birlikte standart tam sayı türleri hakkında ayrıntılar verir -
Tür | Depolama boyutu | Değer aralığı |
---|---|---|
kömür | 1 bayt | -128 ila 127 veya 0 ila 255 |
imzasız karakter | 1 bayt | 0 ile 255 |
imzalı karakter | 1 bayt | -128 ila 127 |
int | 2 veya 4 bayt | -32.768 ila 32.767 veya -2.147.483.648 ila 2.147.483.647 |
imzasız int | 2 veya 4 bayt | 0 - 65,535 veya 0 - 4,294,967,295 |
kısa | 2 bayt | -32.768 ila 32.767 |
imzasız kısa | 2 bayt | 0 ile 65.535 |
uzun | 4 bayt | -2.147.483.648 ile 2.147.483.647 |
imzasız uzun | 4 bayt | 0 ile 4.294.967.295 |
Belirli bir platformda bir türün veya değişkenin tam boyutunu elde etmek için, sizeofŞebeke. Sizeof (type) ifadesi , nesnenin veya türün bayt cinsinden depolama boyutunu verir. Aşağıda, herhangi bir makinede int türünün boyutunu elde etmek için bir örnek verilmiştir -
#import <Foundation/Foundation.h>
int main() {
NSLog(@"Storage size for int : %d \n", sizeof(int));
return 0;
}
Yukarıdaki programı derleyip çalıştırdığınızda, Linux'ta aşağıdaki sonucu verir -
2013-09-07 22:21:39.155 demo[1340] Storage size for int : 4
Kayan Nokta Türleri
Aşağıdaki tablo, depolama boyutları ve değer aralıkları ve bunların hassasiyeti ile standart kayan nokta türleri hakkında ayrıntılar verir -
Tür | Depolama boyutu | Değer aralığı | Hassas |
---|---|---|---|
yüzen | 4 bayt | 1.2E-38 - 3.4E + 38 | 6 ondalık basamak |
çift | 8 bayt | 2.3E-308 ila 1.7E + 308 | 15 ondalık basamak |
uzun çift | 10 bayt | 3.4E-4932 ila 1.1E + 4932 | 19 ondalık basamak |
Float.h başlık dosyası, bu değerleri ve programlarınızdaki gerçek sayıların ikili gösterimiyle ilgili diğer ayrıntıları kullanmanıza izin veren makroları tanımlar. Aşağıdaki örnek, bir kayan nokta türü tarafından alınan depolama alanını ve aralık değerlerini yazdıracaktır -
#import <Foundation/Foundation.h>
int main() {
NSLog(@"Storage size for float : %d \n", sizeof(float));
return 0;
}
Yukarıdaki programı derleyip çalıştırdığınızda, Linux'ta aşağıdaki sonucu verir -
2013-09-07 22:22:21.729 demo[3927] Storage size for float : 4
Boşluk Tipi
Void türü hiçbir değerin mevcut olmadığını belirtir. Üç tür durumda kullanılır -
Sr.No. | Türler ve Açıklama |
---|---|
1 | Function returns as void Objective-C'de değer döndürmeyen çeşitli işlevler vardır veya void döndürdüklerini söyleyebilirsiniz. Dönüş değeri olmayan bir işlevin dönüş türü geçersizdir. Örneğin,void exit (int status); |
2 | Function arguments as void Objective-C'de herhangi bir parametre kabul etmeyen çeşitli fonksiyonlar vardır. Parametresi olmayan bir işlev geçersiz olarak kabul edebilir. Örneğin,int rand(void); |
Boşluk türü bu noktada size anlaşılmayabilir, bu yüzden devam edelim ve bu kavramları ilerleyen bölümlerde ele alacağız.
Değişken, programlarımızın değiştirebileceği bir depolama alanına verilen addan başka bir şey değildir. Objective-C'deki her değişkenin, değişkenin belleğinin boyutunu ve düzenini belirleyen belirli bir türü vardır; o hafızada saklanabilecek değerlerin aralığı; ve değişkene uygulanabilecek işlemler kümesi.
Bir değişkenin adı harflerden, rakamlardan ve alt çizgi karakterinden oluşabilir. Bir harf veya alt çizgiyle başlamalıdır. Büyük ve küçük harfler farklıdır çünkü Objective-C büyük / küçük harfe duyarlıdır. Önceki bölümde açıklanan temel türlere bağlı olarak, aşağıdaki temel değişken türleri olacaktır -
Sr.No. | Tip ve Açıklama |
---|---|
1 | char Genellikle tek bir sekizli (bir bayt). Bu bir tamsayı türüdür. |
2 | int Makine için en doğal tam sayı boyutu. |
3 | float Tek duyarlıklı kayan nokta değeri. |
4 | double Çift duyarlıklı bir kayan nokta değeri. |
5 | void Türün yokluğunu temsil eder. |
Objective-C programlama dili ayrıca, Numaralandırma, İşaretçi, Dizi, Yapı, Birleşim vb. Gibi sonraki bölümlerde ele alacağımız çeşitli diğer değişken türlerini tanımlamaya izin verir. Bu bölüm için, sadece temel değişken türlerini inceleyelim.
Objective-C'deki Değişken Tanımı
Değişken tanımı, derleyiciye değişken için depolamanın nerede ve ne kadar oluşturulacağını söylemek anlamına gelir. Bir değişken tanımı, bir veri türünü belirtir ve bu türden bir veya daha fazla değişkenin aşağıdaki gibi bir listesini içerir -
type variable_list;
Buraya, type char, w_char, int, float, double, bool veya herhangi bir kullanıcı tanımlı nesne vb. dahil olmak üzere geçerli bir Objective-C veri türü olmalı ve variable_listvirgülle ayrılmış bir veya daha fazla tanımlayıcı adından oluşabilir. Bazı geçerli beyanlar burada gösterilmektedir -
int i, j, k;
char c, ch;
float f, salary;
double d;
Çizgi int i, j, k;hem i, j ve k değişkenlerini bildirir hem de tanımlar; bu, derleyiciye int türünde i, j ve k adlı değişkenler oluşturma talimatını verir.
Değişkenler bildirimlerinde başlatılabilir (bir başlangıç değeri atanabilir). Başlatıcı, bir eşittir işaretinden ve ardından aşağıdaki gibi sabit bir ifadeden oluşur:
type variable_name = value;
Bazı örnekler -
extern int d = 3, f = 5; // declaration of d and f.
int d = 3, f = 5; // definition and initializing d and f.
byte z = 22; // definition and initializes z.
char x = 'x'; // the variable x has the value 'x'.
Başlatıcı olmadan tanım için: statik depolama süresi olan değişkenler dolaylı olarak NULL ile başlatılır (tüm baytlar 0 değerine sahiptir); diğer tüm değişkenlerin başlangıç değeri tanımsızdır.
Objective-C'de Değişken Beyanı
Değişken bildirimi, derleyiciye verilen tür ve adla bir değişken bulunduğuna dair güvence sağlar, böylece derleyici, değişken hakkında tam ayrıntıya ihtiyaç duymadan daha fazla derlemeye devam eder. Değişken bildiriminin anlamı yalnızca derleme sırasında vardır, derleyici, programın bağlanması sırasında gerçek değişken bildirimine ihtiyaç duyar.
Değişken bildirimi, birden fazla dosya kullandığınızda ve değişkeninizi programın bağlanması sırasında kullanılabilecek dosyalardan birinde tanımladığınızda yararlıdır. Kullanacaksınexternherhangi bir yerde bir değişken bildirmek için anahtar kelime. Bir değişkeni Objective-C programınızda birden çok kez tanımlayabilseniz de, bir dosyada, işlevde veya bir kod bloğunda yalnızca bir kez tanımlanabilir.
Misal
Değişkenlerin en üstte bildirildiği, ancak ana işlev içinde tanımlandığı ve başlatıldığı aşağıdaki örneği deneyin -
#import <Foundation/Foundation.h>
// Variable declaration:
extern int a, b;
extern int c;
extern float f;
int main () {
/* variable definition: */
int a, b;
int c;
float f;
/* actual initialization */
a = 10;
b = 20;
c = a + b;
NSLog(@"value of c : %d \n", c);
f = 70.0/3.0;
NSLog(@"value of f : %f \n", f);
return 0;
}
Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -
2013-09-07 22:43:31.695 demo[14019] value of c : 30
2013-09-07 22:43:31.695 demo[14019] value of f : 23.333334
Aynı kavram, bildirimi sırasında bir işlev adı sağladığınız ve gerçek tanımının başka herhangi bir yerde verilebildiği işlev bildirimi için de geçerlidir. Aşağıdaki örnekte, C işlevi kullanılarak açıklanmıştır ve bildiğiniz gibi Objective-C, C stili işlevleri de destekler -
// function declaration
int func();
int main() {
// function call
int i = func();
}
// function definition
int func() {
return 0;
}
Objective-C'deki Lvalues ve Rvalues
Objective-C'de iki tür ifade vardır -
lvalue- Bir bellek konumuna başvuran ifadeler "lvalue" ifadesi olarak adlandırılır. Bir değer, bir ödevin sol veya sağ tarafı olarak görünebilir.
rvalue- rvalue terimi, bellekteki bazı adreslerde depolanan bir veri değerini ifade eder. Bir rvalue, kendisine atanmış bir değere sahip olamayan bir ifadedir; bu, bir atamanın sağ tarafında değil sol tarafında bir r değerinin görünebileceği anlamına gelir.
Değişkenler ldeğerlerdir ve bu nedenle bir atamanın sol tarafında görünebilir. Sayısal değişmez değerler r değerleridir ve bu nedenle atanamaz ve sol tarafta görünmeyebilir. Aşağıdaki geçerli bir ifadedir -
int g = 20;
Ancak aşağıdaki geçerli bir ifade değildir ve derleme zamanı hatası oluşturur -
10 = 20;
Sabit değerler, programın yürütülmesi sırasında değiştiremeyeceği sabit değerleri ifade eder. Bu sabit değerler ayrıcaliterals.
Sabitler, bir tamsayı sabiti, kayan sabit, bir karakter sabiti veya bir dize değişmezi gibi temel veri türlerinden herhangi biri olabilir . Ayrıca numaralandırma sabitleri de vardır.
constants değerlerinin tanımlarından sonra değiştirilememesi dışında normal değişkenler gibi ele alınır.
Tamsayı değişmez değerleri
Tamsayı değişmez değeri, ondalık, sekizlik veya onaltılık sabit olabilir. Bir önek, tabanı veya tabanı belirtir: Onaltılık için 0x veya 0X, sekizlik için 0 ve ondalık için hiçbir şey.
Bir tamsayı değişmezi ayrıca, sırasıyla işaretsiz ve uzun için U ve L'nin bir kombinasyonu olan bir son eke sahip olabilir. Son ek, büyük veya küçük harf olabilir ve herhangi bir sırada olabilir.
İşte tamsayı değişmez değerlerine bazı örnekler -
212 /* Legal */
215u /* Legal */
0xFeeL /* Legal */
078 /* Illegal: 8 is not an octal digit */
032UU /* Illegal: cannot repeat a suffix */
Aşağıda, çeşitli Tamsayı değişmez değerlerinin diğer örnekleri verilmiştir -
85 /* decimal */
0213 /* octal */
0x4b /* hexadecimal */
30 /* int */
30u /* unsigned int */
30l /* long */
30ul /* unsigned long */
Kayan nokta değişmez değerleri
Bir kayan noktalı değişmez değerin bir tamsayı bölümü, bir ondalık noktası, bir kesirli bölümü ve bir üs bölümü vardır. Kayan noktalı değişmez değerleri ondalık veya üstel biçimde temsil edebilirsiniz.
Ondalık biçimi kullanarak temsil ederken, ondalık noktayı, üssü veya her ikisini de eklemelisiniz ve üstel biçimi kullanarak temsil ederken, tamsayı bölümünü, kesirli bölümü veya her ikisini birden eklemelisiniz. İmzalı üs, e veya E ile tanıtılır.
İşte kayan noktalı değişmez değerlere bazı örnekler -
3.14159 /* Legal */
314159E-5L /* Legal */
510E /* Illegal: incomplete exponent */
210f /* Illegal: no decimal or exponent */
.e55 /* Illegal: missing integer or fraction */
Karakter sabitleri
Karakter değişmezleri tek tırnak içine alınır, örneğin 'x' ve basit bir değişken içinde saklanabilir char yazın.
Bir karakter değişmezi düz bir karakter (ör. "X"), bir kaçış dizisi (ör. "\ T") veya evrensel bir karakter (ör. "\ U02C0") olabilir.
Bir ters eğik çizgi ile ilerlediklerinde C'de belirli karakterler vardır, bunların özel anlamları olacaktır ve satırsonu (\ n) veya sekme (\ t) gibi temsil etmek için kullanılırlar. Burada, bu tür kaçış dizisi kodlarının bir listesi var -
Kaçış dizisi | Anlam |
---|---|
\\ | \ karakteri |
\ ' | karakter |
\ " | "karakteri |
\? | ? karakter |
\ a | Uyarı veya zil |
\ b | Geri tuşu |
\ f | Form besleme |
\ n | Yeni hat |
\ r | Satırbaşı |
\ t | Yatay sekme |
\ v | Dikey sekme |
\ ooo | Bir ila üç basamaklı sekizlik sayı |
\ xhh. . . | Bir veya daha fazla basamağın onaltılık sayısı |
Aşağıda, birkaç kaçış dizisi karakterini gösteren örnek verilmiştir -
#import <Foundation/Foundation.h>
int main() {
NSLog(@"Hello\tWorld\n\n");
return 0;
}
Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -
2013-09-07 22:17:17.923 demo[17871] Hello World
Dize değişmez değerleri
Dize değişmezleri veya sabitleri çift tırnak "" içine alınır. Bir dize, karakter değişmezlerine benzer karakterler içerir: düz karakterler, kaçış dizileri ve evrensel karakterler.
Dize değişmezlerini kullanarak ve boşlukları kullanarak uzun bir satırı birden çok satıra bölebilirsiniz.
İşte dize değişmezlerine bazı örnekler. Üç formun tümü aynı dizelerdir.
"hello, dear"
"hello, \
dear"
"hello, " "d" "ear"
Sabitleri Tanımlama
C'de sabitleri tanımlamanın iki basit yolu vardır -
Kullanma #define önişlemci.
Kullanma const anahtar kelime.
#Define Ön İşlemci
Aşağıda, bir sabiti tanımlamak için #define önişlemcisini kullanacak form verilmiştir -
#define identifier value
Aşağıdaki örnek bunu ayrıntılı olarak açıklamaktadır -
#import <Foundation/Foundation.h>
#define LENGTH 10
#define WIDTH 5
#define NEWLINE '\n'
int main() {
int area;
area = LENGTH * WIDTH;
NSLog(@"value of area : %d", area);
NSLog(@"%c", NEWLINE);
return 0;
}
Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -
2013-09-07 22:18:16.637 demo[21460] value of area : 50
2013-09-07 22:18:16.638 demo[21460]
Sabit Anahtar Kelime
Kullanabilirsiniz const aşağıdaki gibi belirli bir türe sahip sabitleri bildirmek için önek -
const type variable = value;
Aşağıdaki örnek bunu ayrıntılı olarak açıklamaktadır -
#import <Foundation/Foundation.h>
int main() {
const int LENGTH = 10;
const int WIDTH = 5;
const char NEWLINE = '\n';
int area;
area = LENGTH * WIDTH;
NSLog(@"value of area : %d", area);
NSLog(@"%c", NEWLINE);
return 0;
}
Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -
2013-09-07 22:19:24.780 demo[25621] value of area : 50
2013-09-07 22:19:24.781 demo[25621]
CAPITALS'ta sabitleri tanımlamanın iyi bir programlama uygulaması olduğuna dikkat edin.
Operatör, derleyiciye belirli matematiksel veya mantıksal işlemleri gerçekleştirmesini söyleyen bir semboldür. Objective-C dili yerleşik operatörler açısından zengindir ve aşağıdaki operatör türlerini sağlar -
- Aritmetik operatörler
- İlişkisel Operatörler
- Mantıksal operatörler
- Bitsel Operatörler
- Atama Operatörleri
- Çeşitli Operatörler
Bu eğitim, aritmetik, ilişkisel, mantıksal, bitsel, atama ve diğer operatörleri tek tek açıklayacaktır.
Aritmetik operatörler
Aşağıdaki tablo, Objective-C dili tarafından desteklenen tüm aritmetik operatörleri göstermektedir. Değişken varsayA 10 ve değişken tutar B 20 tutar, sonra -
Örnekleri Göster
Şebeke | Açıklama | Misal |
---|---|---|
+ | İki işlenen ekler | A + B 30 verecek |
- | İlk işlenenden ikinci işleneni çıkarır | A - B -10 verir |
* | Her iki işleneni de çarpar | A * B 200 verecek |
/ | Payı paydaya böler | B / A 2 verecek |
% | Modül İşleci ve bir tamsayı bölmesinden sonra kalanı | B% A 0 verir |
++ | Arttırma operatörü, tamsayı değerini bir artırır | A ++, 11 verecek |
- | Azaltma operatörü tamsayı değerini bir azaltır | A-- 9 verecek |
İlişkisel Operatörler
Aşağıdaki tablo, Objective-C dili tarafından desteklenen tüm ilişkisel operatörleri göstermektedir. Değişken varsayA 10 ve değişken tutar B 20 tutar, sonra -
Örnekleri Göster
Şebeke | Açıklama | Misal |
---|---|---|
== | İki işlenenin değerlerinin eşit olup olmadığını kontrol eder; evet ise, o zaman durum gerçek olur. | (A == B) doğru değil. |
! = | İki işlenenin değerlerinin eşit olup olmadığını kontrol eder; değerler eşit değilse, koşul doğru olur. | (A! = B) doğrudur. |
> | Soldaki işlenenin değerinin sağ işlenenin değerinden büyük olup olmadığını kontrol eder; evet ise, o zaman durum gerçek olur. | (A> B) doğru değil. |
< | Sol işlenenin değerinin sağ işlenenin değerinden küçük olup olmadığını kontrol eder; evet ise, o zaman durum gerçek olur. | (A <B) doğrudur. |
> = | Sol işlenenin değerinin sağ işlenenin değerinden büyük veya ona eşit olup olmadığını kontrol eder; evet ise, o zaman durum gerçek olur. | (A> = B) doğru değil. |
<= | Sol işlenenin değerinin sağ işlenenin değerinden küçük veya ona eşit olup olmadığını kontrol eder; evet ise, o zaman durum gerçek olur. | (A <= B) doğrudur. |
Mantıksal operatörler
Aşağıdaki tablo, Objective-C dili tarafından desteklenen tüm mantıksal operatörleri göstermektedir. Değişken varsayA 1 ve değişken tutar B 0 tutar, sonra -
Örnekleri Göster
Şebeke | Açıklama | Misal |
---|---|---|
&& | Mantıksal AND operatörü çağrıldı. Her iki işlenen de sıfır değilse, koşul doğru olur. | (A && B) yanlıştır. |
|| | Mantıksal VEYA Operatörü çağrıldı. İki işlenenden herhangi biri sıfır değilse, koşul doğru olur. | (A || B) doğrudur. |
! | Mantıksal NOT Operatörü olarak adlandırıldı. İşleneninin mantıksal durumunu tersine çevirmek için kullanın. Bir koşul doğruysa, Mantıksal NOT operatörü yanlış yapar. | ! (A && B) doğrudur. |
Bitsel Operatörler
Bitsel operatör bitler üzerinde çalışır ve bit işlem gerçekleştirir. &, | Ve ^ için doğruluk tabloları aşağıdaki gibidir -
p | q | p & q | p | q | p ^ q |
---|---|---|---|---|
0 | 0 | 0 | 0 | 0 |
0 | 1 | 0 | 1 | 1 |
1 | 1 | 1 | 1 | 0 |
1 | 0 | 0 | 1 | 1 |
A = 60 ise; ve B = 13; şimdi ikili biçimde aşağıdaki gibi olacaklar -
Bir = 0011 1100
B = 0000 1101
-----------------
A&B = 0000 1100
A | B = 0011 1101
A ^ B = 0011 0001
~ A = 1100 0011
Objective-C dili tarafından desteklenen Bitwise operatörleri aşağıdaki tabloda listelenmiştir. A değişkeninin 60, B değişkeninin 13 olduğunu varsayalım -
Örnekleri Göster
Şebeke | Açıklama | Misal |
---|---|---|
& | İkili VE İşleci, her iki işlenende de varsa sonuca bir bit kopyalar. | (A & B) 0000 1100 olan 12 verecek |
| | İkili VEYA İşleci, işlenenlerden herhangi birinde varsa bir bit kopyalar. | (A | B), 0011 1101 olan 61 verecek |
^ | İkili XOR İşleci, bir işlenen içinde ayarlanmışsa, ancak her ikisinde birden değil ise biti kopyalar. | (A ^ B), 0011 0001 olan 49 verecek |
~ | İkili Birler Tamamlayıcı Operatörü tekli ve bitleri 'çevirme' etkisine sahiptir. | (~ A), 2'nin tümleyen formunda 1100 0011 olan -61'i verecektir. |
<< | İkili Sol Kaydırma Operatörü. Soldaki işlenenler değeri, sağ işlenen tarafından belirtilen bit sayısı kadar sola taşınır. | Bir << 2 240 verir, yani 1111 0000 |
>> | İkili Sağ Shift Operatörü. Soldaki işlenenler değeri, sağ işlenen tarafından belirtilen bit sayısı kadar sağa taşınır. | A >> 2, 0000 1111 olan 15 verir |
Atama Operatörleri
Objective-C dili tarafından desteklenen aşağıdaki atama operatörleri vardır -
Örnekleri Göster
Şebeke | Açıklama | Misal |
---|---|---|
= | Basit atama operatörü, sağ taraftaki işlenenlerden sol taraftaki işlenenlere değerler atar | C = A + B, A + B'nin değerini C'ye atar |
+ = | VE atama operatörü ekle, Sol operanda sağ operandı ekler ve sonucu sol operanda atar. | C + = A, C = C + A'ya eşdeğerdir |
- = | Çıkar VE atama operatörü, Sağ operandı sol operanddan çıkarır ve sonucu sol operanda atar. | C - = A, C = C - A'ya eşdeğerdir |
* = | AND atama operatörünü çarpın, sağ operandı sol operandla çarpar ve sonucu sol operanda atar | C * = A, C = C * A'ya eşdeğerdir |
/ = | Bölme VE atama operatörü, Sol operandı sağ operand ile böler ve sonucu sol operanda atar | C / = A, C = C / A'ya eşdeğerdir |
% = | Modül VE atama operatörü, iki işlenen kullanarak modülü alır ve sonucu sol operanda atar | C% = A eşdeğerdir C = C% A |
<< = | Sol kaydırma VE atama operatörü | C << = 2, C = C << 2 ile aynıdır |
>> = | Sağ kaydırma VE atama operatörü | C >> = 2, C = C >> 2 ile aynıdır |
& = | Bitsel AND atama operatörü | C & = 2, C = C & 2 ile aynıdır |
^ = | bit düzeyinde özel OR ve atama operatörü | C ^ = 2, C = C ^ 2 ile aynıdır |
| = | bitsel kapsayıcı OR ve atama operatörü | C | = 2, C = C | ile aynıdır | 2 |
Çeşitli Operatörler ↦ sizeof & ternary
Aşağıdakileri içeren birkaç önemli operatör vardır: sizeof ve ? : Objective-C Language tarafından desteklenmektedir.
Örnekleri Göster
Şebeke | Açıklama | Misal |
---|---|---|
boyutu() | Bir değişkenin boyutunu döndürür. | sizeof (a), burada a tam sayıdır, 4 döndürür. |
& | Bir değişkenin adresini verir. | & a; değişkenin gerçek adresini verecektir. |
* | Bir değişkene işaretçi. | * a; bir değişkene işaret eder. |
? : | Koşullu İfade | Koşul doğruysa? Ardından X değeri: Aksi takdirde Y değeri |
Objective-C'de Operatör Önceliği
Operatör önceliği, bir ifadedeki terimlerin gruplandırılmasını belirler. Bu, bir ifadenin nasıl değerlendirileceğini etkiler. Bazı operatörler diğerlerinden daha yüksek önceliğe sahiptir; örneğin, çarpma operatörü toplama operatöründen daha yüksek önceliğe sahiptir -
Örneğin, x = 7 + 3 * 2; burada, x operatörü + 'dan daha yüksek önceliğe sahip olduğu için 20 değil, 13 atanır, bu nedenle önce 3 * 2 ile çarpılır ve sonra 7'ye eklenir.
Burada, en yüksek önceliğe sahip operatörler tablonun en üstünde, en düşük olanlar ise en altta görünür. Bir ifade içinde, daha yüksek öncelikli operatörler ilk olarak değerlendirilecektir.
Kategori | Şebeke | İlişkisellik |
---|---|---|
Postfix | () [] ->. ++ - - | Soldan sağa |
Tekli | + -! ~ ++ - - (tür) * & sizeof | Sağdan sola |
Çarpımsal | * /% | Soldan sağa |
Katkı | + - | Soldan sağa |
Vardiya | << >> | Soldan sağa |
İlişkisel | <<=>> = | Soldan sağa |
Eşitlik | ==! = | Soldan sağa |
Bitsel ÖZELVEYA | ^ | Soldan sağa |
Bit tabanlı VEYA | | | Soldan sağa |
Mantıksal AND | && | Soldan sağa |
Mantıksal VEYA | || | Soldan sağa |
Koşullu | ?: | Sağdan sola |
Görev | = + = - = * = / =% = >> = << = & = ^ = | = | Sağdan sola |
Virgül | , | Soldan sağa |
Bir kod bloğunu birkaç kez çalıştırmanız gereken bir durum olabilir. Genel olarak, ifadeler sıralı olarak yürütülür: Bir fonksiyondaki ilk ifade önce çalıştırılır, ardından ikincisi vb.
Programlama dilleri, daha karmaşık yürütme yollarına izin veren çeşitli kontrol yapıları sağlar.
Bir döngü deyimi, bir deyimi veya deyim grubunu birden çok kez yürütmemize olanak tanır ve aşağıdaki programlama dillerinin çoğunda bir döngü deyiminin genel biçimidir -
Objective-C programlama dili, döngü gereksinimlerini karşılamak için aşağıdaki döngü türlerini sağlar. Ayrıntılarını kontrol etmek için aşağıdaki bağlantıları tıklayın.
Sr.No. | Döngü Tipi ve Açıklaması |
---|---|
1 | döngü sırasında Belirli bir koşul doğruyken bir ifadeyi veya ifade grubunu tekrarlar. Döngü gövdesini çalıştırmadan önce koşulu test eder. |
2 | döngü için Bir dizi ifadeyi birden çok kez çalıştırın ve döngü değişkenini yöneten kodu kısaltın. |
3 | döngü sırasında yap Döngü gövdesinin sonundaki koşulu test etmesi dışında bir while ifadesi gibi. |
4 | İç içe geçmiş döngüler Döngü while, for veya do.. while diğerlerinin içinde bir veya daha fazla döngü kullanabilirsiniz. |
Döngü Kontrol İfadeleri
Döngü kontrol ifadeleri, yürütmeyi normal sırasından değiştirir. Yürütme bir kapsam bıraktığında, bu kapsamda oluşturulan tüm otomatik nesneler yok edilir.
Objective-C aşağıdaki kontrol ifadelerini destekler. Ayrıntılarını kontrol etmek için aşağıdaki bağlantıları tıklayın.
Sr.No. | Kontrol İfadesi ve Açıklama |
---|---|
1 | break ifadesi Sonlandırır loop veya switch deyim ve yürütmeyi döngü veya anahtardan hemen sonra deyime aktarır. |
2 | devam ifadesi Döngünün vücudunun geri kalanını atlamasına ve yinelemeden önce durumunu hemen yeniden test etmesine neden olur. |
Sonsuz Döngü
Bir koşul asla yanlış olmazsa döngü sonsuz döngü haline gelir. fordöngü geleneksel olarak bu amaç için kullanılır. For döngüsünü oluşturan üç ifadeden hiçbiri gerekli olmadığından, koşullu ifadeyi boş bırakarak sonsuz bir döngü oluşturabilirsiniz.
#import <Foundation/Foundation.h>
int main () {
for( ; ; ) {
NSLog(@"This loop will run forever.\n");
}
return 0;
}
Koşullu ifade olmadığında, doğru olduğu varsayılır. Bir başlatma ve artırma ifadesine sahip olabilirsiniz, ancak Objective-C programcıları daha çok sonsuz bir döngüyü belirtmek için for (;;) yapısını kullanır.
Karar verme yapıları, programcının, program tarafından değerlendirilecek veya test edilecek bir veya daha fazla koşulu, koşulun doğru olduğu belirlenirse yürütülecek bir ifade veya ifadeyle birlikte belirtmesini ve isteğe bağlı olarak, koşulun doğru olması durumunda yürütülecek diğer ifadeleri gerektirir. yanlış olduğu belirlenir.
Aşağıda, programlama dillerinin çoğunda bulunan tipik bir karar verme yapısının genel biçimi verilmiştir -
Objective-C programlama dili herhangi bir non-zero ve non-null değerler olarak trueve eğer öyleyse zero veya null, sonra olduğu varsayılır false değer.
Objective-C programlama dili, aşağıdaki türden karar verme ifadeleri sağlar. Ayrıntılarını kontrol etmek için aşağıdaki bağlantıları tıklayın -
Sr.No. | Açıklama ve Açıklama |
---|---|
1 | eğer ifadesi Bir if statement bir boole ifadesinin ardından bir veya daha fazla ifadeden oluşur. |
2 | if ... else ifadesi Bir if statement ardından isteğe bağlı bir else statement, boolean ifadesi yanlış olduğunda çalıştırılır. |
3 | yuvalanmış if ifadeleri Birini kullanabilirsin if veya else if bir başkasının içinde ifade if veya else if beyan (lar). |
4 | anahtar deyimi Bir switch ifadesi, bir değişkenin bir değerler listesine karşı eşitlik açısından test edilmesine izin verir. |
5 | yuvalanmış anahtar ifadeleri Birini kullanabilirsin switch bir başkasının içinde ifade switch beyan (lar). |
? : Şebeke
Biz kapladık conditional operator ? : değiştirmek için kullanılabilecek önceki bölümde if...elseifadeler. Aşağıdaki genel biçime sahiptir -
Exp1 ? Exp2 : Exp3;
Burada Exp1, Exp2 ve Exp3 ifadelerdir. Kolonun kullanımına ve yerleştirilmesine dikkat edin.
A'nın değeri? ifade şu şekilde belirlenir: Exp1 değerlendirilir. Doğruysa, Exp2 değerlendirilir ve tamamının değeri olur? ifade. Exp1 yanlışsa, Exp3 değerlendirilir ve değeri ifadenin değeri olur.
Bir işlev, birlikte bir görevi yerine getiren bir grup deyimdir. Her Objective-C programının bir C işlevi vardır;main()ve en önemsiz programların tümü ek işlevler tanımlayabilir.
Kodunuzu ayrı işlevlere bölebilirsiniz. Kodunuzu farklı işlevler arasında nasıl böleceğiniz size bağlıdır, ancak mantıksal olarak bölme genellikle her işlevin belirli bir görevi yerine getirmesidir.
Bir işlev declarationderleyiciye bir işlevin adı, dönüş türü ve parametreleri hakkında bilgi verir. Bir işlevdefinition işlevin gerçek gövdesini sağlar.
Temel olarak Amaç-C'de, işlevi yöntem olarak adlandırıyoruz.
Objective-C temel çerçevesi, programınızın çağırabileceği çok sayıda yerleşik yöntem sağlar. Örneğin yöntemappendString() dizeyi başka bir dizeye eklemek için.
Bir yöntem, bir işlev veya bir alt rutin veya bir prosedür vb. Gibi çeşitli adlarla bilinir.
Bir Yöntem Tanımlama
Objective-C programlama dilinde bir yöntem tanımının genel biçimi aşağıdaki gibidir -
- (return_type) method_name:( argumentType1 )argumentName1
joiningArgument2:( argumentType2 )argumentName2 ...
joiningArgumentn:( argumentTypen )argumentNamen {
body of the function
}
Objective-C programlama dilinde bir yöntem tanımı, bir yöntem başlığı ve bir yöntem gövdesinden oluşur . İşte bir yöntemin tüm bölümleri -
Return Type- Bir yöntem bir değer döndürebilir. return_typeişlevin döndürdüğü değerin veri türüdür. Bazı yöntemler bir değer döndürmeden istenen işlemleri gerçekleştirir. Bu durumda, dönüş_türü anahtar kelimedirvoid.
Method Name- Bu, yöntemin gerçek adıdır. Yöntem adı ve parametre listesi birlikte yöntem imzasını oluşturur.
Arguments- Tartışma, yer tutucu gibidir. Bir işlev çağrıldığında, bağımsız değişkene bir değer iletirsiniz. Bu değere gerçek parametre veya bağımsız değişken adı verilir. Parametre listesi, bir yöntemin argümanlarının türü, sırası ve sayısını ifade eder. Bağımsız değişkenler isteğe bağlıdır; yani bir yöntem hiçbir argüman içermeyebilir.
Joining Argument - Bir katılma argümanı, okumayı kolaylaştırmak ve onu çağırırken netleştirmek içindir.
Method Body - Yöntem gövdesi, yöntemin ne yaptığını tanımlayan bir dizi deyim içerir.
Misal
Aşağıda, adı verilen bir yöntemin kaynak kodu verilmiştir max(). Bu yöntem iki parametre num1 ve num2 alır ve ikisi arasındaki maksimum değeri döndürür -
/* function returning the max between two numbers */
- (int) max:(int) num1 secondNumber:(int) num2 {
/* local variable declaration */
int result;
if (num1 > num2) {
result = num1;
} else {
result = num2;
}
return result;
}
Yöntem Bildirimleri
Bir metod declarationderleyiciye bir işlev adı ve yöntemin nasıl çağrılacağını anlatır. Fonksiyonun gerçek gövdesi ayrı ayrı tanımlanabilir.
Bir yöntem bildirimi aşağıdaki bölümlerden oluşur -
- (return_type) function_name:( argumentType1 )argumentName1
joiningArgument2:( argumentType2 )argumentName2 ...
joiningArgumentn:( argumentTypen )argumentNamen;
Yukarıda tanımlanan max () fonksiyonu için, yöntem bildirimi aşağıdadır -
-(int) max:(int)num1 andNum2:(int)num2;
Bir kaynak dosyada bir yöntem tanımladığınızda ve bu yöntemi başka bir dosyada çağırdığınızda yöntem bildirimi gereklidir. Böyle bir durumda, işlevi çağıran dosyanın en üstünde işlevi bildirmelisiniz.
Bir yöntemi çağırmak
Bir Objective-C yöntemi oluştururken, fonksiyonun ne yapması gerektiğine dair bir tanım verirsiniz. Bir yöntemi kullanmak için, tanımlanan görevi gerçekleştirmek için o işlevi çağırmanız gerekecektir.
Bir program bir işlevi çağırdığında, program kontrolü çağrılan yönteme aktarılır. Çağrılan bir yöntem tanımlanmış görevi yerine getirir ve return ifadesi yürütüldüğünde veya işlev biten kapanış ayracına ulaşıldığında, program kontrolünü ana programa geri döndürür.
Bir yöntemi çağırmak için, gerekli parametreleri yöntem adıyla birlikte iletmeniz yeterlidir ve eğer yöntem bir değer döndürürse, döndürülen değeri saklayabilirsiniz. Örneğin -
#import <Foundation/Foundation.h>
@interface SampleClass:NSObject
/* method declaration */
- (int)max:(int)num1 andNum2:(int)num2;
@end
@implementation SampleClass
/* method returning the max between two numbers */
- (int)max:(int)num1 andNum2:(int)num2 {
/* local variable declaration */
int result;
if (num1 > num2) {
result = num1;
} else {
result = num2;
}
return result;
}
@end
int main () {
/* local variable definition */
int a = 100;
int b = 200;
int ret;
SampleClass *sampleClass = [[SampleClass alloc]init];
/* calling a method to get max value */
ret = [sampleClass max:a andNum2:b];
NSLog(@"Max value is : %d\n", ret );
return 0;
}
Max () işlevini main () işleviyle birlikte tuttum ve kaynak koduna uydum. Son yürütülebilir dosyayı çalıştırırken, aşağıdaki sonucu üretir -
2013-09-07 22:28:45.912 demo[26080] Max value is : 200
İşlev Argümanları
Bir işlev bağımsız değişkenler kullanacaksa, bağımsız değişkenlerin değerlerini kabul eden değişkenleri bildirmelidir. Bu değişkenlereformal parameters işlevin.
Biçimsel parametreler, işlevin içindeki diğer yerel değişkenler gibi davranır ve işleve girişte oluşturulur ve çıkışta yok edilir.
Bir işlevi çağırırken, bağımsız değişkenlerin bir işleve aktarılmasının iki yolu vardır -
Sr.No. | Çağrı Tipi ve Açıklaması |
---|---|
1 | Değere göre ara Bu yöntem, bir bağımsız değişkenin gerçek değerini işlevin biçimsel parametresine kopyalar. Bu durumda, işlevin içindeki parametrede yapılan değişikliklerin bağımsız değişken üzerinde hiçbir etkisi yoktur. |
2 | Referansla arayın Bu yöntem, bir argümanın adresini biçimsel parametreye kopyalar. Fonksiyonun içinde adres, çağrıda kullanılan gerçek argümana erişmek için kullanılır. Bu, parametrede yapılan değişikliklerin bağımsız değişkeni etkilediği anlamına gelir. |
Varsayılan olarak, Objective-C, call by valueargümanlar iletmek için. Genel olarak bu, bir işlev içindeki kodun işlevi çağırmak için kullanılan bağımsız değişkenleri değiştiremeyeceği anlamına gelir ve yukarıda bahsedilen örnek, max () işlevi çağrılırken aynı yöntemi kullanır.
Objective-C sınıfı, verileri ilgili davranışla birleştiren bir nesneyi tanımlar. Bazen, bir yöntem koleksiyonundan çok tek bir görevi veya davranış birimini temsil etmek mantıklıdır.
Bloklar, C, Objective-C ve C ++ 'ya eklenen, yöntemlere veya işlevlere sanki değerlermiş gibi aktarılabilen farklı kod segmentleri oluşturmanıza olanak tanıyan dil düzeyinde bir özelliktir. Bloklar, Objective-C nesneleridir; bu, NSArray veya NSDictionary gibi koleksiyonlara eklenebilecekleri anlamına gelir. Ayrıca, diğer programlama dillerindeki kapanışlara veya lambdalara benzer hale getirerek, çevreleyen kapsamdaki değerleri yakalama yeteneğine sahiptirler.
Basit Blok bildirimi sözdizimi
returntype (^blockName)(argumentType);
Basit blok uygulaması
returntype (^blockName)(argumentType)= ^{
};
İşte basit bir örnek
void (^simpleBlock)(void) = ^{
NSLog(@"This is a block");
};
Kullanarak bloğu çağırabiliriz
simpleBlock();
Bloklar Bağımsız Değişkenler ve Dönüş Değerleri Alır
Bloklar da tıpkı yöntemler ve işlevler gibi argümanlar alabilir ve değerleri döndürebilir.
Burada argümanlar ve dönüş değerleri olan bir bloğu uygulamak ve çağırmak için basit bir örnek verilmiştir.
double (^multiplyTwoValues)(double, double) =
^(double firstValue, double secondValue) {
return firstValue * secondValue;
};
double result = multiplyTwoValues(2,4);
NSLog(@"The result is %f", result);
Tür tanımlarını kullanan bloklar
İşte typedef'i blokta kullanan basit bir örnek. Lütfen bu örneğe dikkat edindoesn't work üzerinde online compilerşimdilik. KullanımXCode aynısını çalıştırmak için.
#import <Foundation/Foundation.h>
typedef void (^CompletionBlock)();
@interface SampleClass:NSObject
- (void)performActionWithCompletion:(CompletionBlock)completionBlock;
@end
@implementation SampleClass
- (void)performActionWithCompletion:(CompletionBlock)completionBlock {
NSLog(@"Action Performed");
completionBlock();
}
@end
int main() {
/* my first program in Objective-C */
SampleClass *sampleClass = [[SampleClass alloc]init];
[sampleClass performActionWithCompletion:^{
NSLog(@"Completion is called to intimate action is performed.");
}];
return 0;
}
Derleyelim ve çalıştıralım, aşağıdaki sonucu verecektir -
2013-09-10 08:13:57.155 demo[284:303] Action Performed
2013-09-10 08:13:57.157 demo[284:303] Completion is called to intimate action is performed.
Bloklar iOS uygulamalarında ve Mac OS X'te daha fazla kullanılmaktadır. Bu nedenle blokların kullanımını anlamak daha önemlidir.
Objective-C programlama dilinde int, float, bool gibi temel veri türlerini nesne biçiminde kaydetmek için,
Objective-C, NSNumber ile çalışmak için bir dizi yöntem sağlar ve önemli olanlar aşağıdaki tabloda listelenmiştir.
Sr.No. | Yöntem ve Açıklama |
---|---|
1 | + (NSNumber *)numberWithBool:(BOOL)value Belirli bir değeri içeren bir NSNumber nesnesi oluşturur ve onu BOOL olarak değerlendirerek döndürür. |
2 | + (NSNumber *)numberWithChar:(char)value Belirli bir değeri içeren bir NSNumber nesnesi oluşturur ve onu işaretli bir karakter olarak değerlendirerek döndürür. |
3 | + (NSNumber *)numberWithDouble:(double)value Belirli bir değeri içeren bir NSNumber nesnesi oluşturur ve onu double olarak değerlendirerek döndürür. |
4 | + (NSNumber *)numberWithFloat:(float)value Belirli bir değeri içeren bir NSNumber nesnesi oluşturur ve onu kayan nokta olarak değerlendirerek döndürür. |
5 | + (NSNumber *)numberWithInt:(int)value Belirli bir değeri içeren bir NSNumber nesnesi oluşturur ve onu işaretli tamsayı olarak değerlendirerek döndürür. |
6 | + (NSNumber *)numberWithInteger:(NSInteger)value Belirli bir değeri içeren bir NSNumber nesnesi oluşturur ve onu bir NSInteger olarak değerlendirerek döndürür. |
7 | - (BOOL)boolValue Alıcının değerini BOOL olarak döndürür. |
8 | - (char)charValue Alıcının değerini bir karakter olarak döndürür. |
9 | - (double)doubleValue Alıcının değerini double olarak döndürür. |
10 | - (float)floatValue Alıcının değerini bir kayan nokta olarak döndürür. |
11 | - (NSInteger)integerValue Alıcının değerini NSInteger olarak döndürür. |
12 | - (int)intValue Alıcının değerini tamsayı olarak döndürür. |
13 | - (NSString *)stringValue Alıcının değerini insan tarafından okunabilir bir dize olarak döndürür. |
Burada, iki sayıyı çarpan ve çarpımı döndüren NSNumber kullanımına ilişkin basit bir örnek verilmiştir.
#import <Foundation/Foundation.h>
@interface SampleClass:NSObject
- (NSNumber *)multiplyA:(NSNumber *)a withB:(NSNumber *)b;
@end
@implementation SampleClass
- (NSNumber *)multiplyA:(NSNumber *)a withB:(NSNumber *)b {
float number1 = [a floatValue];
float number2 = [b floatValue];
float product = number1 * number2;
NSNumber *result = [NSNumber numberWithFloat:product];
return result;
}
@end
int main() {
NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];
SampleClass *sampleClass = [[SampleClass alloc]init];
NSNumber *a = [NSNumber numberWithFloat:10.5];
NSNumber *b = [NSNumber numberWithFloat:10.0];
NSNumber *result = [sampleClass multiplyA:a withB:b];
NSString *resultString = [result stringValue];
NSLog(@"The product is %@",resultString);
[pool drain];
return 0;
}
Şimdi programı derleyip çalıştırdığımızda aşağıdaki sonucu alacağız.
2013-09-14 18:53:40.575 demo[16787] The product is 105
Objective-C programlama dili adı verilen bir veri yapısı sağlar the array, aynı türden öğelerin sabit boyutlu sıralı bir koleksiyonunu depolayabilir. Bir dizi, bir veri koleksiyonunu depolamak için kullanılır, ancak bir diziyi aynı türden bir değişkenler koleksiyonu olarak düşünmek genellikle daha kullanışlıdır.
Sayı0, sayı1, ... ve sayı99 gibi tek tek değişkenleri bildirmek yerine, sayılar gibi bir dizi değişkeni bildirir ve temsil etmek için sayılar [0], sayılar [1] ve ..., sayılar [99] kullanırsınız bireysel değişkenler. Bir dizideki belirli bir öğeye bir dizinle erişilir.
Tüm diziler bitişik bellek konumlarından oluşur. En düşük adres ilk öğeye ve en yüksek adres son öğeye karşılık gelir.
Dizileri Bildirme
Objective-C'de bir dizi bildirmek için, bir programcı aşağıdaki gibi öğelerin türünü ve bir dizinin gerektirdiği öğe sayısını belirtir:
type arrayName [ arraySize ];
Buna tek boyutlu dizi denir . arraySize sıfırdan büyük bir tamsayı sabiti olmalı ve typeherhangi bir geçerli Objective-C veri türü olabilir. Örneğin, 10 öğeli bir dizi bildirmek içinbalance double türünde, bu ifadeyi kullanın -
double balance[10];
Şimdi, denge 10 çift sayıya kadar tutmaya yetecek değişken bir dizidir.
Dizileri Başlatma
Objective-C'de bir diziyi tek tek veya aşağıdaki gibi tek bir ifade kullanarak başlatabilirsiniz -
double balance[5] = {1000.0, 2.0, 3.4, 17.0, 50.0};
Küme parantezleri {} arasındaki değerlerin sayısı, köşeli parantezler [] arasındaki dizi için belirttiğimiz öğelerin sayısından büyük olamaz. Aşağıda, dizinin tek bir öğesini atamak için bir örnek verilmiştir -
Dizinin boyutunu atlarsanız, başlatmayı tutacak kadar büyük bir dizi oluşturulur. Bu nedenle, yazarsanız -
double balance[] = {1000.0, 2.0, 3.4, 17.0, 50.0};
Önceki örnekte yaptığınız gibi tam olarak aynı diziyi yaratacaksınız.
balance[4] = 50.0;
Yukarıdaki ifade, dizideki 5. öğe numarasına 50.0 değerini atar. 4. dizini olan dizi 5. olacaktır, yani son eleman, çünkü tüm diziler ilk elemanlarının dizini olarak 0'a sahiptir ve buna taban dizini de denir. Aşağıda, yukarıda tartıştığımız aynı dizinin resimli temsili verilmiştir -
Dizi Öğelerine Erişim
Dizi adını indeksleyerek bir elemana erişilir. Bu, elemanın dizini dizinin isminden sonra köşeli parantez içine yerleştirilerek yapılır. Örneğin -
double salary = balance[9];
Yukarıdaki ifade diziden 10. elemanı alacak ve değeri maaş değişkenine atayacaktır. Aşağıda, yukarıda bahsedilen üç kavramın tamamını kullanacak bir örnek verilmiştir. bildirim, atama ve dizilere erişim -
#import <Foundation/Foundation.h>
int main () {
int n[ 10 ]; /* n is an array of 10 integers */
int i,j;
/* initialize elements of array n to 0 */
for ( i = 0; i < 10; i++ ) {
n[ i ] = i + 100; /* set element at location i to i + 100 */
}
/* output each array element's value */
for (j = 0; j < 10; j++ ) {
NSLog(@"Element[%d] = %d\n", j, n[j] );
}
return 0;
}
Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -
2013-09-14 01:24:06.669 demo[16508] Element[0] = 100
2013-09-14 01:24:06.669 demo[16508] Element[1] = 101
2013-09-14 01:24:06.669 demo[16508] Element[2] = 102
2013-09-14 01:24:06.669 demo[16508] Element[3] = 103
2013-09-14 01:24:06.669 demo[16508] Element[4] = 104
2013-09-14 01:24:06.669 demo[16508] Element[5] = 105
2013-09-14 01:24:06.669 demo[16508] Element[6] = 106
2013-09-14 01:24:06.669 demo[16508] Element[7] = 107
2013-09-14 01:24:06.669 demo[16508] Element[8] = 108
2013-09-14 01:24:06.669 demo[16508] Element[9] = 109
Ayrıntılı Objective-C Dizileri
Diziler Objective-C için önemlidir ve çok daha fazla ayrıntıya ihtiyaç duyar. Bir Objective-C programcısı için açık olması gereken, dizi ile ilgili aşağıdaki birkaç önemli kavram vardır:
Sr.No. | Konsept ve Açıklama |
---|---|
1 | Çok boyutlu diziler Objective-C, çok boyutlu dizileri destekler. Çok boyutlu dizinin en basit şekli iki boyutlu dizidir. |
2 | Dizileri işlevlere geçirme Dizinin adını indeks olmadan belirterek işleve bir diziye bir işaretçi iletebilirsiniz. |
3 | Bir işlevden dizi döndür Objective-C, bir işlevin bir dizi döndürmesine izin verir. |
4 | Bir diziye işaretçi Herhangi bir indeks olmadan sadece dizi adını belirterek bir dizinin ilk öğesine bir işaretçi oluşturabilirsiniz. |
Objective-C'deki işaretçiler öğrenmesi kolay ve eğlencelidir. Bazı Objective-C programlama görevleri işaretçilerle daha kolay gerçekleştirilir ve dinamik bellek ayırma gibi diğer görevler işaretçiler kullanılmadan gerçekleştirilemez. Bu nedenle, mükemmel bir Objective-C programcısı olmak için işaretçileri öğrenmek gerekli hale geliyor. Bunları basit ve kolay adımlarla öğrenmeye başlayalım.
Bildiğiniz gibi, her değişken bir bellek konumudur ve her bellek konumunun, bellekteki bir adresi belirten ve işareti (&) operatörü kullanılarak erişilebilen tanımlanmış adresi vardır. Tanımlanan değişkenlerin adresini yazdıracak aşağıdaki örneği düşünün -
#import <Foundation/Foundation.h>
int main () {
int var1;
char var2[10];
NSLog(@"Address of var1 variable: %x\n", &var1 );
NSLog(@"Address of var2 variable: %x\n", &var2 );
return 0;
}
Yukarıdaki kod derlendiğinde ve çalıştırıldığında, sonucu aşağıdaki gibi üretir -
2013-09-13 03:18:45.727 demo[17552] Address of var1 variable: 1c0843fc
2013-09-13 03:18:45.728 demo[17552] Address of var2 variable: 1c0843f0
Yani, hafıza adresinin ne olduğunu ve ona nasıl erişileceğini anladınız, bu yüzden kavramın temeli bitti. Şimdi bir göstericinin ne olduğunu görelim.
İşaretçiler Nelerdir?
Bir pointerdeğeri başka bir değişkenin adresi, yani bellek yerinin doğrudan adresi olan bir değişkendir. Herhangi bir değişken veya sabit gibi, herhangi bir değişken adresini saklamak için kullanmadan önce bir işaretçi bildirmelisiniz. Bir işaretçi değişken bildiriminin genel şekli -
type *var-name;
Buraya, typeişaretçinin temel türüdür; geçerli bir Objective-C veri türü olmalı vevar-nameişaretçi değişkeninin adıdır. İşaretçi bildirmek için kullandığınız yıldız işareti *, çarpma için kullandığınız yıldız işaretiyle aynıdır. Bununla birlikte, bu ifadede yıldız işareti, bir değişkeni işaretçi olarak belirlemek için kullanılmaktadır. Aşağıda geçerli işaretçi bildirimi verilmiştir -
int *ip; /* pointer to an integer */
double *dp; /* pointer to a double */
float *fp; /* pointer to a float */
char *ch /* pointer to a character */
Tam sayı, kayan nokta, karakter veya başka türlü tüm işaretçilerin değerinin gerçek veri türü aynıdır, bir bellek adresini temsil eden uzun bir onaltılık sayı. Farklı veri türlerinin işaretçileri arasındaki tek fark, işaretçinin işaret ettiği değişken veya sabitin veri türüdür.
İşaretçiler nasıl kullanılır?
Çok sık işaretçiler yardımı ile yapacağımız birkaç önemli işlem var. (a) bir işaretçi değişkeni tanımlıyoruz, (b) bir değişkenin adresini bir işaretçiye atayın ve (c)son olarak, işaretçi değişkeninde bulunan adresteki değere erişin. Bu, tekli operatör kullanılarak yapılır*işleneni tarafından belirtilen adreste bulunan değişkenin değerini döndürür. Aşağıdaki örnek bu işlemlerden yararlanmaktadır -
#import <Foundation/Foundation.h>
int main () {
int var = 20; /* actual variable declaration */
int *ip; /* pointer variable declaration */
ip = &var; /* store address of var in pointer variable*/
NSLog(@"Address of var variable: %x\n", &var );
/* address stored in pointer variable */
NSLog(@"Address stored in ip variable: %x\n", ip );
/* access the value using the pointer */
NSLog(@"Value of *ip variable: %d\n", *ip );
return 0;
}
Yukarıdaki kod derlendiğinde ve çalıştırıldığında, sonucu aşağıdaki gibi üretir -
2013-09-13 03:20:21.873 demo[24179] Address of var variable: 337ed41c
2013-09-13 03:20:21.873 demo[24179] Address stored in ip variable: 337ed41c
2013-09-13 03:20:21.874 demo[24179] Value of *ip variable: 20
Objective-C'de NULL İşaretçiler
Atanacak tam adresiniz yoksa bir işaretçi değişkenine bir NULL değeri atamak her zaman iyi bir uygulamadır. Bu, değişken bildirimi sırasında yapılır. NULL atanmış bir işaretçi,null Işaretçi.
NULL işaretçisi, birkaç standart kütüphanede tanımlanan sıfır değerine sahip bir sabittir. Aşağıdaki programı düşünün -
#import <Foundation/Foundation.h>
int main () {
int *ptr = NULL;
NSLog(@"The value of ptr is : %x\n", ptr );
return 0;
}
Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -
2013-09-13 03:21:19.447 demo[28027] The value of ptr is : 0
Çoğu işletim sisteminde, programların 0 adresindeki belleğe erişmesine izin verilmez, çünkü bu bellek işletim sistemi tarafından ayrılmıştır. Bununla birlikte, hafıza adresi 0'ın özel bir anlamı vardır; işaretçinin erişilebilir bir bellek konumuna işaret etmesinin amaçlanmadığını belirtir. Ancak geleneksel olarak, eğer bir işaretçi boş (sıfır) değeri içeriyorsa, hiçbir şeyi göstermediği varsayılır.
Boş gösterici olup olmadığını kontrol etmek için, aşağıdaki gibi bir if ifadesi kullanabilirsiniz -
if(ptr) /* succeeds if p is not null */
if(!ptr) /* succeeds if p is null */
Ayrıntılı Amaç-C İşaretçileri
İşaretçilerin pek çok ama kolay konsepti vardır ve bunlar Objective-C programlaması için çok önemlidir. Bir Objective-C programcısı için açık olması gereken birkaç önemli işaretçi kavramı vardır:
Sr.No. | Konsept ve Açıklama |
---|---|
1 | Objective-C - İşaretçi aritmetiği İşaretçilerde kullanılabilen dört aritmetik operatör vardır: ++, -, +, - |
2 | Objective-C - İşaretçiler dizisi Bir dizi işaretçi tutacak diziler tanımlayabilirsiniz. |
3 | Objective-C - İşaretçiye işaretçi Objective-C, bir işaretçi üzerinde bir işaretçiye sahip olmanızı sağlar. |
4 | Hedef-C'deki işlevlere işaretçiler aktarma Bir bağımsız değişkeni başvuru veya adrese göre iletmek, iletilen bağımsız değişkenin çağrılan işlev tarafından çağrılan işlevde değiştirilmesini sağlar. |
5 | Objective-C'deki fonksiyonlardan dönüş işaretçisi Objective-C, bir fonksiyonun yerel değişkene, statik değişkene ve dinamik olarak ayrılmış belleğe bir işaretçi döndürmesine izin verir. |
Objective-C programlama dilindeki dize, NSString kullanılarak temsil edilir ve alt sınıfı NSMutableString, dize nesneleri oluşturmak için çeşitli yollar sağlar. Bir dizge nesnesi oluşturmanın en basit yolu, Objective-C @ "..." yapısını kullanmaktır -
NSString *greeting = @"Hello";
Bir dizi oluşturmak ve yazdırmak için basit bir örnek aşağıda gösterilmiştir.
#import <Foundation/Foundation.h>
int main () {
NSString *greeting = @"Hello";
NSLog(@"Greeting message: %@\n", greeting );
return 0;
}
Yukarıdaki kod derlendiğinde ve çalıştırıldığında, aşağıdaki gibi bir sonuç üretir -
2013-09-11 01:21:39.922 demo[23926] Greeting message: Hello
Objective-C, dizeleri işlemek için çok çeşitli yöntemleri destekler -
Sr.No. | Yöntem ve Amaç |
---|---|
1 | - (NSString *)capitalizedString; Alıcının büyük harfle yazılmış temsilini döndürür. |
2 | - (unichar)characterAtIndex:(NSUInteger)index; Belirli bir dizi konumundaki karakteri döndürür. |
3 | - (double)doubleValue; Alıcının metninin kayan nokta değerini double olarak döndürür. |
4 | - (float)floatValue; Alıcının metninin kayan nokta değerini bir kayan nokta olarak döndürür. |
5 | - (BOOL)hasPrefix:(NSString *)aString; Belirli bir dizenin alıcının başlangıç karakterleriyle eşleşip eşleşmediğini gösteren bir Boolean değeri döndürür. |
6 | - (BOOL)hasSuffix:(NSString *)aString; Belirli bir dizenin alıcının son karakterleriyle eşleşip eşleşmediğini gösteren bir Boolean değeri döndürür. |
7 | - (id)initWithFormat:(NSString *)format ...; Kalan bağımsız değişken değerlerinin yerine konulduğu bir şablon olarak belirli bir biçim dizesi kullanılarak başlatılan bir NSString nesnesini döndürür. |
8 | - (NSInteger)integerValue; Alıcının metninin NSInteger değerini döndürür. |
9 | - (BOOL)isEqualToString:(NSString *)aString; Belirli bir dizenin, değişmez Unicode tabanlı bir karşılaştırma kullanarak alıcıya eşit olup olmadığını gösteren bir Boolean değeri döndürür. |
10 | - (NSUInteger)length; Alıcıdaki Unicode karakterlerinin sayısını döndürür. |
11 | - (NSString *)lowercaseString; Alıcının küçük harfli temsilini döndürür. |
12 | - (NSRange)rangeOfString:(NSString *)aString; Alıcıda belirli bir dizenin ilk oluşum aralığını bulur ve döndürür. |
13 | - (NSString *)stringByAppendingFormat:(NSString *)format ...; Alıcıya, belirli bir biçim dizesinden ve aşağıdaki bağımsız değişkenlerden oluşturulmuş bir dize ekleyerek yapılan bir dize döndürür. |
14 | - (NSString *)stringByTrimmingCharactersInSet:(NSCharacterSet *)set; Belirli bir karakter kümesinde bulunan alıcı karakterlerin her iki ucundan da çıkarılarak yapılmış yeni bir dize döndürür. |
15 | - (NSString *)substringFromIndex:(NSUInteger)anIndex; Verilen dizindeki alıcının karakterlerini sonuna kadar içeren yeni bir dize döndürür. |
Aşağıdaki örnek, yukarıda belirtilen işlevlerden birkaçını kullanır -
#import <Foundation/Foundation.h>
int main () {
NSString *str1 = @"Hello";
NSString *str2 = @"World";
NSString *str3;
int len ;
NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];
/* uppercase string */
str3 = [str2 uppercaseString];
NSLog(@"Uppercase String : %@\n", str3 );
/* concatenates str1 and str2 */
str3 = [str1 stringByAppendingFormat:@"World"];
NSLog(@"Concatenated string: %@\n", str3 );
/* total length of str3 after concatenation */
len = [str3 length];
NSLog(@"Length of Str3 : %d\n", len );
/* InitWithFormat */
str3 = [[NSString alloc] initWithFormat:@"%@ %@",str1,str2];
NSLog(@"Using initWithFormat: %@\n", str3 );
[pool drain];
return 0;
}
Yukarıdaki kod derlendiğinde ve çalıştırıldığında, aşağıdaki gibi bir sonuç üretir -
2013-09-11 01:15:45.069 demo[30378] Uppercase String : WORLD
2013-09-11 01:15:45.070 demo[30378] Concatenated string: HelloWorld
2013-09-11 01:15:45.070 demo[30378] Length of Str3 : 10
2013-09-11 01:15:45.070 demo[30378] Using initWithFormat: Hello World
NSString Class Reference'da Objective-C NSString ile ilgili yöntemlerin tam bir listesini bulabilirsiniz .
Amaç-C dizileri, aynı türden birkaç veri öğesini tutabilen değişken türlerini tanımlamanıza izin verir, ancak structure Objective-C programlamada bulunan ve farklı türlerdeki veri öğelerini birleştirmenize olanak tanıyan kullanıcı tanımlı başka bir veri türüdür.
Yapılar bir kaydı temsil etmek için kullanılır, Farz edin ki kitaplarınızı bir kütüphanede takip etmek istiyorsunuz. Her kitapla ilgili aşağıdaki öznitelikleri izlemek isteyebilirsiniz -
- Title
- Author
- Subject
- Kitap kimliği
Bir Yapının Tanımlanması
Bir yapıyı tanımlamak için, structBeyan. Struct deyimi, programınız için birden fazla üye içeren yeni bir veri türünü tanımlar. Struct ifadesinin biçimi şudur -
struct [structure tag] {
member definition;
member definition;
...
member definition;
} [one or more structure variables];
structure tagisteğe bağlıdır ve her üye tanımı, int i gibi normal bir değişken tanımıdır; veya float f; veya başka herhangi bir geçerli değişken tanımı. Yapının tanımının sonunda, son noktalı virgülden önce, bir veya daha fazla yapı değişkeni belirtebilirsiniz, ancak bu isteğe bağlıdır. Kitap yapısını şu şekilde beyan edersiniz:
struct Books {
NSString *title;
NSString *author;
NSString *subject;
int book_id;
} book;
Yapı Üyelerine Erişim
Bir yapının herhangi bir üyesine erişmek için, member access operator (.). Üye erişim operatörü, yapı değişkeni adı ile erişmek istediğimiz yapı üyesi arasında bir dönem olarak kodlanır. Kullanırdınstructyapı tipindeki değişkenleri tanımlamak için anahtar kelime. Aşağıda yapının kullanımını açıklamak için örnek verilmiştir -
#import <Foundation/Foundation.h>
struct Books {
NSString *title;
NSString *author;
NSString *subject;
int book_id;
};
int main() {
struct Books Book1; /* Declare Book1 of type Book */
struct Books Book2; /* Declare Book2 of type Book */
/* book 1 specification */
Book1.title = @"Objective-C Programming";
Book1.author = @"Nuha Ali";
Book1.subject = @"Objective-C Programming Tutorial";
Book1.book_id = 6495407;
/* book 2 specification */
Book2.title = @"Telecom Billing";
Book2.author = @"Zara Ali";
Book2.subject = @"Telecom Billing Tutorial";
Book2.book_id = 6495700;
/* print Book1 info */
NSLog(@"Book 1 title : %@\n", Book1.title);
NSLog(@"Book 1 author : %@\n", Book1.author);
NSLog(@"Book 1 subject : %@\n", Book1.subject);
NSLog(@"Book 1 book_id : %d\n", Book1.book_id);
/* print Book2 info */
NSLog(@"Book 2 title : %@\n", Book2.title);
NSLog(@"Book 2 author : %@\n", Book2.author);
NSLog(@"Book 2 subject : %@\n", Book2.subject);
NSLog(@"Book 2 book_id : %d\n", Book2.book_id);
return 0;
}
Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -
2013-09-14 04:20:07.947 demo[20591] Book 1 title : Objective-C Programming
2013-09-14 04:20:07.947 demo[20591] Book 1 author : Nuha Ali
2013-09-14 04:20:07.947 demo[20591] Book 1 subject : Objective-C Programming Tutorial
2013-09-14 04:20:07.947 demo[20591] Book 1 book_id : 6495407
2013-09-14 04:20:07.947 demo[20591] Book 2 title : Telecom Billing
2013-09-14 04:20:07.947 demo[20591] Book 2 author : Zara Ali
2013-09-14 04:20:07.947 demo[20591] Book 2 subject : Telecom Billing Tutorial
2013-09-14 04:20:07.947 demo[20591] Book 2 book_id : 6495700
Fonksiyon Bağımsız Değişkenleri Olarak Yapılar
Bir yapıyı, başka bir değişken veya işaretçi ilettiğinizde çok benzer bir şekilde işlev bağımsız değişkeni olarak iletebilirsiniz. Yapı değişkenlerine yukarıdaki örnekte eriştiğiniz şekilde erişirsiniz -
#import <Foundation/Foundation.h>
struct Books {
NSString *title;
NSString *author;
NSString *subject;
int book_id;
};
@interface SampleClass:NSObject
/* function declaration */
- (void) printBook:( struct Books) book ;
@end
@implementation SampleClass
- (void) printBook:( struct Books) book {
NSLog(@"Book title : %@\n", book.title);
NSLog(@"Book author : %@\n", book.author);
NSLog(@"Book subject : %@\n", book.subject);
NSLog(@"Book book_id : %d\n", book.book_id);
}
@end
int main() {
struct Books Book1; /* Declare Book1 of type Book */
struct Books Book2; /* Declare Book2 of type Book */
/* book 1 specification */
Book1.title = @"Objective-C Programming";
Book1.author = @"Nuha Ali";
Book1.subject = @"Objective-C Programming Tutorial";
Book1.book_id = 6495407;
/* book 2 specification */
Book2.title = @"Telecom Billing";
Book2.author = @"Zara Ali";
Book2.subject = @"Telecom Billing Tutorial";
Book2.book_id = 6495700;
SampleClass *sampleClass = [[SampleClass alloc]init];
/* print Book1 info */
[sampleClass printBook: Book1];
/* Print Book2 info */
[sampleClass printBook: Book2];
return 0;
}
Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -
2013-09-14 04:34:45.725 demo[8060] Book title : Objective-C Programming
2013-09-14 04:34:45.725 demo[8060] Book author : Nuha Ali
2013-09-14 04:34:45.725 demo[8060] Book subject : Objective-C Programming Tutorial
2013-09-14 04:34:45.725 demo[8060] Book book_id : 6495407
2013-09-14 04:34:45.725 demo[8060] Book title : Telecom Billing
2013-09-14 04:34:45.725 demo[8060] Book author : Zara Ali
2013-09-14 04:34:45.725 demo[8060] Book subject : Telecom Billing Tutorial
2013-09-14 04:34:45.725 demo[8060] Book book_id : 6495700
Yapılara İşaretçiler
İşaretçileri başka bir değişkene aşağıdaki gibi tanımladığınız gibi yapılara çok benzer şekilde tanımlayabilirsiniz -
struct Books *struct_pointer;
Şimdi, bir yapı değişkeninin adresini yukarıda tanımlanan işaretçi değişkeninde saklayabilirsiniz. Bir yapı değişkeninin adresini bulmak için, & operatörünü yapının adının önüne aşağıdaki gibi yerleştirin -
struct_pointer = &Book1;
Bir yapının üyelerine o yapının bir işaretçisi kullanarak erişmek için, -> operatörünü aşağıdaki gibi kullanmanız gerekir -
struct_pointer->title;
Yapı işaretçisini kullanarak yukarıdaki örneği yeniden yazalım, bunun sizin için kavramı anlamanızın kolay olacağını umalım -
#import <Foundation/Foundation.h>
struct Books {
NSString *title;
NSString *author;
NSString *subject;
int book_id;
};
@interface SampleClass:NSObject
/* function declaration */
- (void) printBook:( struct Books *) book ;
@end
@implementation SampleClass
- (void) printBook:( struct Books *) book {
NSLog(@"Book title : %@\n", book->title);
NSLog(@"Book author : %@\n", book->author);
NSLog(@"Book subject : %@\n", book->subject);
NSLog(@"Book book_id : %d\n", book->book_id);
}
@end
int main() {
struct Books Book1; /* Declare Book1 of type Book */
struct Books Book2; /* Declare Book2 of type Book */
/* book 1 specification */
Book1.title = @"Objective-C Programming";
Book1.author = @"Nuha Ali";
Book1.subject = @"Objective-C Programming Tutorial";
Book1.book_id = 6495407;
/* book 2 specification */
Book2.title = @"Telecom Billing";
Book2.author = @"Zara Ali";
Book2.subject = @"Telecom Billing Tutorial";
Book2.book_id = 6495700;
SampleClass *sampleClass = [[SampleClass alloc]init];
/* print Book1 info by passing address of Book1 */
[sampleClass printBook:&Book1];
/* print Book2 info by passing address of Book2 */
[sampleClass printBook:&Book2];
return 0;
}
Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -
2013-09-14 04:38:13.942 demo[20745] Book title : Objective-C Programming
2013-09-14 04:38:13.942 demo[20745] Book author : Nuha Ali
2013-09-14 04:38:13.942 demo[20745] Book subject : Objective-C Programming Tutorial
2013-09-14 04:38:13.942 demo[20745] Book book_id : 6495407
2013-09-14 04:38:13.942 demo[20745] Book title : Telecom Billing
2013-09-14 04:38:13.942 demo[20745] Book author : Zara Ali
2013-09-14 04:38:13.942 demo[20745] Book subject : Telecom Billing Tutorial
2013-09-14 04:38:13.942 demo[20745] Book book_id : 6495700
Bit Alanları
Bit Alanları, bir yapıda verilerin paketlenmesine izin verir. Bu, özellikle bellek veya veri depolamanın önemli olduğu durumlarda kullanışlıdır. Tipik örnekler -
Birkaç nesneyi bir makine kelimesine paketlemek. örneğin 1 bitlik bayraklar sıkıştırılabilir.
Harici dosya formatlarını okuma - standart olmayan dosya formatları okunabilir. Örn. 9 bitlik tamsayılar.
Objective-C, değişkenin arkasına bit uzunluğu koyarak bunu bir yapı tanımında yapmamızı sağlar. Örneğin -
struct packed_struct {
unsigned int f1:1;
unsigned int f2:1;
unsigned int f3:1;
unsigned int f4:1;
unsigned int type:4;
unsigned int my_int:9;
} pack;
Burada, paketlenmiş yapı 6 üye içerir: Dört adet 1 bit bayrak f1..f3, 4 bitlik bir tür ve 9 bitlik my_int.
Objective-C, alanın maksimum uzunluğunun bilgisayarın tamsayı kelime uzunluğundan daha az veya ona eşit olması koşuluyla, yukarıdaki bit alanlarını olabildiğince kompakt bir şekilde otomatik olarak paketler. Durum böyle değilse, bazı derleyiciler alanlar için bellek örtüşmesine izin verirken, diğerleri sonraki kelimedeki sonraki alanı saklar.
Objective-C Preprocessorderleyicinin bir parçası değildir, ancak derleme sürecinde ayrı bir adımdır. Basit bir ifadeyle, bir Objective-C Ön İşlemcisi yalnızca bir metin değiştirme aracıdır ve derleyiciye gerçek derlemeden önce gerekli ön işlemeyi yapması talimatını verir. Objective-C Ön İşlemcisinden OCPP olarak bahsedeceğiz.
Tüm önişlemci komutları bir pound sembolü (#) ile başlar. Boş olmayan ilk karakter olmalı ve okunabilirlik için bir önişlemci yönergesi ilk sütundan başlamalıdır. Aşağıdaki bölüm, tüm önemli önişlemci direktiflerini listeler -
Sr.No. | Yönerge ve Açıklama |
---|---|
1 | #define Ön işlemci makrosunun yerini alır |
2 | #include Başka bir dosyadan belirli bir başlık ekler |
3 | #undef Bir önişlemci makrosunu tanımlar |
4 | #ifdef Bu makro tanımlanmışsa doğru döndürür |
5 | #ifndef Bu makro tanımlanmamışsa doğru döndürür |
6 | #if Derleme zamanı koşulunun doğru olup olmadığını test eder |
7 | #else #İf için alternatif |
8 | #elif #else an #if tek bir ifadede |
9 | #endif Önişlemci koşullu sona erer |
10 | #error Stderr üzerine hata mesajı yazdırır |
11 | #pragma Standartlaştırılmış bir yöntem kullanarak derleyiciye özel komutlar verir |
Önişlemci Örnekleri
Çeşitli direktifleri anlamak için aşağıdaki örnekleri analiz edin.
#define MAX_ARRAY_LENGTH 20
Bu yönerge OCPP'ye MAX_ARRAY_LENGTH örneklerini 20 ile değiştirmesini söyler . Okunabilirliği artırmak için sabitler için #define kullanın .
#import <Foundation/Foundation.h>
#include "myheader.h"
Bu direktifler OCPP'ye vakıf.h'yi Foundation Frameworkve metni geçerli kaynak dosyaya ekleyin. Sonraki satır OCPP'yemyheader.h yerel dizinden ve içeriği geçerli kaynak dosyaya ekleyin.
#undef FILE_SIZE
#define FILE_SIZE 42
Bu, OCPP'ye mevcut FILE_SIZE tanımını kaldırmasını ve 42 olarak tanımlamasını söyler.
#ifndef MESSAGE
#define MESSAGE "You wish!"
#endif
Bu, OCPP'ye MESAJI yalnızca MESAJ önceden tanımlanmamışsa tanımlamasını söyler.
#ifdef DEBUG
/* Your debugging statements here */
#endif
Bu, OCPP'ye, DEBUG tanımlanmışsa, eklenen ifadeleri işlemi yapmasını söyler. Derleme sırasında -DDEBUG bayrağını gcc derleyicisine iletirseniz bu yararlıdır . Bu, DEBUG'ı tanımlayacaktır, böylece derleme sırasında hata ayıklamayı açıp kapatabilirsiniz.
Önceden Tanımlanmış Makrolar
ANSI C, bir dizi makro tanımlar. Her biri programlamada kullanımınız için mevcut olsa da, önceden tanımlanmış makrolar doğrudan değiştirilmemelidir.
Sr.No. | Makro ve Açıklama |
---|---|
1 | __DATE__ "AA GG YYYY" biçiminde bir karakter değişmez değeri olarak geçerli tarih |
2 | __TIME__ "SS: DD: SS" biçiminde bir karakter değişmez değeri olarak geçerli saat |
3 | __FILE__ Bu, geçerli dosya adını bir dize değişmezi olarak içerir. |
4 | __LINE__ Bu, geçerli satır numarasını bir ondalık sabit olarak içerir. |
5 | __STDC__ Derleyici ANSI standardıyla uyumlu olduğunda 1 olarak tanımlanır. |
Aşağıdaki örneği deneyelim -
#import <Foundation/Foundation.h>
int main() {
NSLog(@"File :%s\n", __FILE__ );
NSLog(@"Date :%s\n", __DATE__ );
NSLog(@"Time :%s\n", __TIME__ );
NSLog(@"Line :%d\n", __LINE__ );
NSLog(@"ANSI :%d\n", __STDC__ );
return 0;
}
Yukarıdaki kod bir dosyada olduğunda main.m derlenir ve yürütülürse aşağıdaki sonucu verir -
2013-09-14 04:46:14.859 demo[20683] File :main.m
2013-09-14 04:46:14.859 demo[20683] Date :Sep 14 2013
2013-09-14 04:46:14.859 demo[20683] Time :04:46:14
2013-09-14 04:46:14.859 demo[20683] Line :8
2013-09-14 04:46:14.859 demo[20683] ANSI :1
Önişlemci Operatörleri
Objective-C ön işlemcisi, makro oluşturmanıza yardımcı olmak için aşağıdaki operatörleri sunar:
Makro Devam (\)
Bir makro genellikle tek bir satırda yer almalıdır. Makro devam operatörü, tek bir satır için çok uzun olan bir makroya devam etmek için kullanılır. Örneğin -
#define message_for(a, b) \
NSLog(@#a " and " #b ": We love you!\n")
Stringize (#)
Dizgi oluşturma veya sayı işareti operatörü ('#'), bir makro tanımında kullanıldığında, bir makro parametresini bir dize sabitine dönüştürür. Bu operatör yalnızca belirli bir bağımsız değişken veya parametre listesi olan bir makroda kullanılabilir. Örneğin -
#import <Foundation/Foundation.h>
#define message_for(a, b) \
NSLog(@#a " and " #b ": We love you!\n")
int main(void) {
message_for(Carole, Debra);
return 0;
}
Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -
2013-09-14 05:46:14.859 demo[20683] Carole and Debra: We love you!
Jeton Yapıştırma (##)
Bir makro tanımındaki belirteç yapıştırma operatörü (##) iki bağımsız değişkeni birleştirir. Makro tanımındaki iki ayrı simgenin tek bir belirteç olarak birleştirilmesine izin verir. Örneğin -
#import <Foundation/Foundation.h>
#define tokenpaster(n) NSLog (@"token" #n " = %d", token##n)
int main(void) {
int token34 = 40;
tokenpaster(34);
return 0;
}
Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -
2013-09-14 05:48:14.859 demo[20683] token34 = 40
Nasıl oldu, çünkü bu örnek önişlemciden aşağıdaki gerçek çıktıyla sonuçlanıyor:
NSLog (@"token34 = %d", token34);
Bu örnek, ## n belirtecinin belirteç34'e birleştirilmesini gösterir ve burada ikisini de kullandık stringize ve token-pasting.
Tanımlı () Operatör
Önişlemci definedoperatörü, bir tanımlayıcının #define kullanılarak tanımlanıp tanımlanmadığını belirlemek için sabit ifadelerde kullanılır. Belirtilen tanımlayıcı tanımlanmışsa, değer doğrudur (sıfır olmayan). Sembol tanımlanmamışsa, değer yanlıştır (sıfır). Tanımlanan operatör şu şekilde belirtilir -
#import <Foundation/Foundation.h>
#if !defined (MESSAGE)
#define MESSAGE "You wish!"
#endif
int main(void) {
NSLog(@"Here is the message: %s\n", MESSAGE);
return 0;
}
Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -
2013-09-14 05:48:19.859 demo[20683] Here is the message: You wish!
Parametreli Makrolar
OCPP'nin güçlü işlevlerinden biri, parametreli makrolar kullanarak işlevleri simüle etme yeteneğidir. Örneğin, bir sayının karesini almak için aşağıdaki gibi bir kodumuz olabilir -
int square(int x) {
return x * x;
}
Yukarıdaki kodu bir makro kullanarak aşağıdaki gibi yeniden yazabiliriz -
#define square(x) ((x) * (x))
Bağımsız değişkenli makrolar, #definekullanılmadan önce yönergesi. Bağımsız değişken listesi parantez içine alınır ve makro adını hemen takip etmelidir. Makro adı ve açık parantez arasında boşluklara izin verilmez. Örneğin -
#import <Foundation/Foundation.h>
#define MAX(x,y) ((x) > (y) ? (x) : (y))
int main(void) {
NSLog(@"Max between 20 and 10 is %d\n", MAX(10, 20));
return 0;
}
Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -
2013-09-14 05:52:15.859 demo[20683] Max between 20 and 10 is 20
Objective-C programlama dili, typedef, bir türe yeni bir ad vermek için kullanabilirsiniz. Aşağıda bir terimi tanımlamak için bir örnek yer almaktadırBYTE bir baytlık sayılar için -
typedef unsigned char BYTE;
Bu tür tanımlamasından sonra, BYTE tanımlayıcı türü için bir kısaltma olarak kullanılabilir. unsigned char, for example:.
BYTE b1, b2;
Geleneksel olarak, kullanıcıya tür adının gerçekten sembolik bir kısaltma olduğunu hatırlatmak için bu tanımlarda büyük harfler kullanılır, ancak aşağıdaki gibi küçük harf kullanabilirsiniz -
typedef unsigned char byte;
Kullanabilirsiniz typedefkullanıcı tanımlı veri türüne bir isim vermek için. Örneğin, yeni bir veri türü tanımlamak için typedef'i yapıyla kullanabilir ve ardından bu veri türünü yapı değişkenlerini doğrudan aşağıdaki gibi tanımlamak için kullanabilirsiniz -
#import <Foundation/Foundation.h>
typedef struct Books {
NSString *title;
NSString *author;
NSString *subject;
int book_id;
} Book;
int main() {
Book book;
book.title = @"Objective-C Programming";
book.author = @"TutorialsPoint";
book.subject = @"Programming tutorial";
book.book_id = 100;
NSLog( @"Book title : %@\n", book.title);
NSLog( @"Book author : %@\n", book.author);
NSLog( @"Book subject : %@\n", book.subject);
NSLog( @"Book Id : %d\n", book.book_id);
return 0;
}
Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -
2013-09-12 12:21:53.745 demo[31183] Book title : Objective-C Programming
2013-09-12 12:21:53.745 demo[31183] Book author : TutorialsPoint
2013-09-12 12:21:53.745 demo[31183] Book subject : Programming tutorial
2013-09-12 12:21:53.745 demo[31183] Book Id : 100
typedef - #define
#define bir Objective-C direktifidir ve aynı zamanda benzer çeşitli veri türleri için takma adları tanımlamak için kullanılır. typedef ancak aşağıdaki farklılıklarla -
typedef yalnızca türlere sembolik adlar vermekle sınırlıdır, oysa #define 1'i BİR olarak tanımlayabileceğiniz gibi değerler için takma ad tanımlamak için de kullanılabilir.
typedef yorumlama derleyici tarafından yapılır. #define ifadeler ön işlemci tarafından işlenir.
Aşağıda #define'ın en basit kullanımı verilmiştir -
#import <Foundation/Foundation.h>
#define TRUE 1
#define FALSE 0
int main( ) {
NSLog( @"Value of TRUE : %d\n", TRUE);
NSLog( @"Value of FALSE : %d\n", FALSE);
return 0;
}
Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -
2013-09-12 12:23:37.993 demo[5160] Value of TRUE : 1
2013-09-12 12:23:37.994 demo[5160] Value of FALSE : 0
Tür atama, bir değişkeni bir veri türünden başka bir veri türüne dönüştürmenin bir yoludur. Örneğin, uzun bir değeri basit bir tamsayı olarak saklamak istiyorsanız, cast long to int yazabilirsiniz. Değerleri bir türden diğerine açıkça şunu kullanarak dönüştürebilirsiniz:cast operator aşağıdaki gibi -
(type_name) expression
Objective-C'de, genellikle 32-bit olması durumunda temel float tipinden ve 64-bit olması durumunda double türünden türetilen kayan nokta işlemi yapmak için CGFloat kullanırız. Cast operatörünün, bir tamsayı değişkeninin diğerine bölünmesinin kayan nokta işlemi olarak gerçekleştirilmesine neden olduğu aşağıdaki örneği düşünün -
#import <Foundation/Foundation.h>
int main() {
int sum = 17, count = 5;
CGFloat mean;
mean = (CGFloat) sum / count;
NSLog(@"Value of mean : %f\n", mean );
return 0;
}
Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -
2013-09-11 01:35:40.047 demo[20634] Value of mean : 3.400000
Burada döküm operatörünün bölmeye göre önceliğe sahip olduğuna dikkat edilmelidir, bu nedenle değeri sum önce yazı tipine dönüştürülür double ve son olarak sayıya bölünerek çift değer elde edilir.
Tür dönüşümleri, derleyici tarafından otomatik olarak gerçekleştirilen örtük olabilir veya açıkça belirtilebilir. cast operator. Tür dönüşümleri gerekli olduğunda döküm operatörünün kullanılması iyi bir programlama uygulaması olarak kabul edilir.
Tamsayı Promosyonu
Tamsayı yükseltme, tam sayı türündeki değerlerin "daha küçük" değerlerinden int veya unsigned int ya dönüştürülür int veya unsigned int. Bir int'e karakter eklemenin bir örneğini düşünün -
#import <Foundation/Foundation.h>
int main() {
int i = 17;
char c = 'c'; /* ascii value is 99 */
int sum;
sum = i + c;
NSLog(@"Value of sum : %d\n", sum );
return 0;
}
Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -
2013-09-11 01:38:28.492 demo[980] Value of sum : 116
Burada, toplamın değeri 116 olarak geliyor çünkü derleyici gerçek toplama işlemini gerçekleştirmeden önce tamsayı yükseltmesi yapıyor ve 'c' değerini ascii'ye dönüştürüyor.
Olağan Aritmetik Dönüşüm
usual arithmetic conversionsdeğerlerini ortak bir türe dönüştürmek için örtük olarak gerçekleştirilir. Derleyici ilk olarak tamsayı yükseltmeyi gerçekleştirir , işlenenler hala farklı türlere sahipse, aşağıdaki hiyerarşide en yüksek görünen türe dönüştürülürler -
Normal aritmetik dönüşümler, atama operatörleri için veya mantıksal operatörler && ve || için gerçekleştirilmez. Kavramı anlamak için aşağıdaki örneği ele alalım -
#import <Foundation/Foundation.h>
int main() {
int i = 17;
char c = 'c'; /* ascii value is 99 */
CGFloat sum;
sum = i + c;
NSLog(@"Value of sum : %f\n", sum );
return 0;
}
Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -
2013-09-11 01:41:39.192 demo[15351] Value of sum : 116.000000
Burada, ilk c'nin tamsayıya dönüştürüldüğünü anlamak basittir, ancak son değer float olduğundan, normal aritmetik dönüşüm uygulanır ve derleyici i ve c'yi float'a dönüştürür ve onları bir float sonucu verecek şekilde ekler.
NSLog yöntemi
Günlükleri yazdırmak için, doğrudan Hello World örneğinden kullandığımız, Objective-C programlama dilinde NSLog yöntemini kullanıyoruz.
"Merhaba Dünya" kelimesini basacak basit bir koda bakalım -
#import <Foundation/Foundation.h>
int main() {
NSLog(@"Hello, World! \n");
return 0;
}
Şimdi programı derleyip çalıştırdığımızda aşağıdaki sonucu alacağız.
2013-09-16 00:32:50.888 demo[16669] Hello, World!
Canlı uygulamalarda günlükleri devre dışı bırakma
Uygulamamızda kullandığımız NSLog'lar cihaz günlüklerine yazdırılacağından günlükleri canlı bir yapıda yazdırmak iyi değildir. Bu nedenle, günlükleri yazdırmak için bir tür tanımı kullanıyoruz ve bunları aşağıda gösterildiği gibi kullanabiliriz.
#import <Foundation/Foundation.h>
#if DEBUG == 0
#define DebugLog(...)
#elif DEBUG == 1
#define DebugLog(...) NSLog(__VA_ARGS__)
#endif
int main() {
DebugLog(@"Debug log, our custom addition gets \
printed during debug only" );
NSLog(@"NSLog gets printed always" );
return 0;
}
Şimdi programı debug modunda derleyip çalıştırdığımızda aşağıdaki sonucu alacağız.
2013-09-11 02:47:07.723 demo[618] Debug log, our custom addition gets printed during debug only
2013-09-11 02:47:07.723 demo[618] NSLog gets printed always
Şimdi programı sürüm modunda derleyip çalıştırdığımızda aşağıdaki sonucu alacağız.
2013-09-11 02:47:45.248 demo[3158] NSLog gets printed always
Objective-C programlamada, hata işleme, aşağıdaki NSError sınıfı ile sağlanır. Foundation framework.
Bir NSError nesnesi, yalnızca bir hata kodu veya hata dizesi kullanılarak mümkün olandan daha zengin ve daha fazla genişletilebilir hata bilgisini kapsüller. Bir NSError nesnesinin temel nitelikleri, bir hata alanı (bir dizeyle temsil edilir), alana özgü bir hata kodu ve uygulamaya özel bilgileri içeren bir kullanıcı bilgisi sözlüğüdür.
NSError
Objective-C programları, kullanıcıların bilgilendirilmesi gereken çalışma zamanı hataları hakkında bilgi vermek için NSError nesnelerini kullanır. Çoğu durumda, bir program bu hata bilgilerini bir iletişim kutusunda veya sayfada görüntüler. Ancak bilgileri yorumlayabilir ve kullanıcıdan hatayı düzeltmeyi denemesini isteyebilir veya hatayı kendi başına düzeltmeyi deneyebilir.
NSError Nesnesi şunlardan oluşur:
Domain - Hata etki alanı önceden tanımlanmış NSError etki alanlarından biri olabilir veya özel bir etki alanını ve etki alanını açıklayan rastgele bir dize sıfır olmamalıdır.
Code - Hatanın hata kodu.
User Info - Hata ve userInfo için userInfo sözlüğü sıfır olabilir.
Aşağıdaki örnek, özel bir hatanın nasıl oluşturulacağını gösterir
NSString *domain = @"com.MyCompany.MyApplication.ErrorDomain";
NSString *desc = NSLocalizedString(@"Unable to complete the process", @"");
NSDictionary *userInfo = @{ NSLocalizedDescriptionKey : desc };
NSError *error = [NSError errorWithDomain:domain code:-101 userInfo:userInfo];
Bir işaretçiye referans olarak iletilen yukarıdaki hata örneğinin tam kodu:
#import <Foundation/Foundation.h>
@interface SampleClass:NSObject
-(NSString *) getEmployeeNameForID:(int) id withError:(NSError **)errorPtr;
@end
@implementation SampleClass
-(NSString *) getEmployeeNameForID:(int) id withError:(NSError **)errorPtr {
if(id == 1) {
return @"Employee Test Name";
} else {
NSString *domain = @"com.MyCompany.MyApplication.ErrorDomain";
NSString *desc =@"Unable to complete the process";
NSDictionary *userInfo = [[NSDictionary alloc]
initWithObjectsAndKeys:desc,
@"NSLocalizedDescriptionKey",NULL];
*errorPtr = [NSError errorWithDomain:domain code:-101
userInfo:userInfo];
return @"";
}
}
@end
int main() {
NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];
SampleClass *sampleClass = [[SampleClass alloc]init];
NSError *error = nil;
NSString *name1 = [sampleClass getEmployeeNameForID:1 withError:&error];
if(error) {
NSLog(@"Error finding Name1: %@",error);
} else {
NSLog(@"Name1: %@",name1);
}
error = nil;
NSString *name2 = [sampleClass getEmployeeNameForID:2 withError:&error];
if(error) {
NSLog(@"Error finding Name2: %@",error);
} else {
NSLog(@"Name2: %@",name2);
}
[pool drain];
return 0;
}
Yukarıdaki örnekte, id 1 ise bir isim döndürüyoruz, aksi takdirde kullanıcı tanımlı hata nesnesini ayarlıyoruz.
Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -
2013-09-14 18:01:00.809 demo[27632] Name1: Employee Test Name
2013-09-14 18:01:00.809 demo[27632] Error finding Name2: Unable to complete the process
Komut satırından Objective-C programlarınıza çalıştırıldıklarında bazı değerler aktarmanız mümkündür. Bu değerlerecommand line arguments ve çoğu zaman programınız için önemlidirler, özellikle de bu değerleri kodun içinde kodlamak yerine dışarıdan kontrol etmek istediğinizde.
Komut satırı argümanları main () fonksiyon argümanları kullanılarak işlenir, burada argc iletilen argümanların sayısını ifade eder ve argv[]programa aktarılan her bir argümana işaret eden bir işaretçi dizisidir. Aşağıda, komut satırından sağlanan herhangi bir argüman olup olmadığını kontrol eden ve buna göre harekete geçen basit bir örnek verilmiştir -
#import <Foundation/Foundation.h>
int main( int argc, char *argv[] ) {
if( argc == 2 ) {
NSLog(@"The argument supplied is %s\n", argv[1]);
} else if( argc > 2 ) {
NSLog(@"Too many arguments supplied.\n");
} else {
NSLog(@"One argument expected.\n");
}
}
Yukarıdaki kod derlendiğinde ve tek bir argümanla çalıştırıldığında, örneğin "test etmek", aşağıdaki sonucu verir.
2013-09-13 03:01:17.333 demo[7640] The argument supplied is testing
Yukarıdaki kod, test1 ve test2 gibi iki bağımsız değişkenle derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir.
2013-09-13 03:01:18.333 demo[7640] Too many arguments supplied.
Yukarıdaki kod derlendiğinde ve herhangi bir argüman iletilmeden çalıştırıldığında, aşağıdaki sonucu verir.
2013-09-13 03:01:18.333 demo[7640] One argument expected
bu not alınmalı argv[0] programın adını taşır ve argv[1]sağlanan ilk komut satırı argümanına bir göstericidir ve * argv [n] son argümandır. Hiçbir bağımsız değişken sağlanmadıysa, argc bir olacaktır, aksi takdirde bir bağımsız değişken iletirseniz, o zamanargc 2 olarak ayarlanmıştır.
Bir boşlukla ayrılmış tüm komut satırı bağımsız değişkenlerini iletirsiniz, ancak bağımsız değişkenin kendisinde bir boşluk varsa, bu tür bağımsız değişkenleri çift tırnak "" veya tek tırnak "içine koyarak iletebilirsiniz. Program adını yazdıracağımız yukarıdaki örneği bir kez daha yeniden yazalım ve ayrıca çift tırnak işareti koyarak bir komut satırı argümanı geçirelim -
#import <Foundation/Foundation.h>
int main( int argc, char *argv[] ) {
NSLog(@"Program name %s\n", argv[0]);
if( argc == 2 ) {
NSLog(@"The argument supplied is %s\n", argv[1]);
} else if( argc > 2 ) {
NSLog(@"Too many arguments supplied.\n");
} else {
NSLog(@"One argument expected.\n");
}
return 0;
}
Yukarıdaki kod derlendiğinde ve boşlukla ayrılmış tek bir argümanla çalıştırıldığında, ancak çift tırnak içinde "Testing1 Testing2" olduğunda, aşağıdaki sonucu verir.
2017-11-30 06:36:59.081 main[71010] Program name main
2017-11-30 06:36:59.082 main[71010] One argument expected.
Objective-C programlama dilinin temel amacı, C programlama diline nesne yönelimi eklemektir ve sınıflar, nesne yönelimli programlamayı destekleyen ve genellikle kullanıcı tanımlı türler olarak adlandırılan Objective-C'nin temel özelliğidir.
Sınıf, bir nesnenin biçimini belirtmek için kullanılır ve veri gösterimini ve bu verileri tek bir düzgün pakette işlemek için yöntemleri birleştirir. Bir sınıf içindeki veriler ve yöntemler, sınıfın üyeleri olarak adlandırılır.
Amaç-C özellikleri
Sınıf, iki farklı bölümde tanımlanmıştır: @interface ve @implementation.
Neredeyse her şey nesneler biçimindedir.
Nesneler mesaj alır ve nesneler genellikle alıcı olarak adlandırılır.
Nesneler, örnek değişkenleri içerir.
Nesnelerin ve örnek değişkenlerinin kapsamı vardır.
Sınıflar bir nesnenin uygulamasını gizler.
Özellikler, diğer sınıflardaki sınıf örneği değişkenlerine erişim sağlamak için kullanılır.
Objective-C Sınıfı Tanımları
Bir sınıf tanımladığınızda, bir veri türü için bir plan tanımlarsınız. Bu aslında herhangi bir veriyi tanımlamaz, ancak sınıf adının ne anlama geldiğini, yani sınıfın bir nesnesinin nelerden oluşacağını ve böyle bir nesne üzerinde hangi işlemlerin gerçekleştirilebileceğini tanımlar.
Bir sınıf tanımı, anahtar kelimeyle başlar @interfaceardından arayüz (sınıf) adı; ve bir çift kaşlı ayraç içine alınmış sınıf gövdesi. Objective-C'de, tüm sınıflar adı verilen temel sınıftan türetilir.NSObject. Tüm Objective-C sınıflarının üst sınıfıdır. Bellek ayırma ve başlatma gibi temel yöntemler sağlar. Örneğin, Box veri türünü anahtar sözcüğünü kullanarak tanımladıkclass aşağıdaki gibi -
@interface Box:NSObject {
//Instance variables
double length; // Length of a box
double breadth; // Breadth of a box
}
@property(nonatomic, readwrite) double height; // Property
@end
Örnek değişkenleri özeldir ve yalnızca sınıf uygulamasından erişilebilir.
Objective-C Nesnelerini Tahsis Etmek ve Başlatmak
Bir sınıf, nesnelerin planlarını sağlar, bu nedenle temelde bir sınıftan bir nesne oluşturulur. Bir sınıfın nesnelerini, temel türlerdeki değişkenleri tanımladığımızla tam olarak aynı türden bildirimlerle bildiririz. Aşağıdaki ifadeler Box sınıfının iki nesnesini bildirir -
Box box1 = [[Box alloc]init]; // Create box1 object of type Box
Box box2 = [[Box alloc]init]; // Create box2 object of type Box
Hem kutu1 hem de kutu2 nesnelerinin kendi veri üyeleri kopyası olacaktır.
Veri Üyelerine Erişim
Bir sınıfın nesnelerinin özelliklerine doğrudan üye erişim operatörü (.) Kullanılarak erişilebilir. İşleri netleştirmek için aşağıdaki örneği deneyelim -
#import <Foundation/Foundation.h>
@interface Box:NSObject {
double length; // Length of a box
double breadth; // Breadth of a box
double height; // Height of a box
}
@property(nonatomic, readwrite) double height; // Property
-(double) volume;
@end
@implementation Box
@synthesize height;
-(id)init {
self = [super init];
length = 1.0;
breadth = 1.0;
return self;
}
-(double) volume {
return length*breadth*height;
}
@end
int main() {
NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];
Box *box1 = [[Box alloc]init]; // Create box1 object of type Box
Box *box2 = [[Box alloc]init]; // Create box2 object of type Box
double volume = 0.0; // Store the volume of a box here
// box 1 specification
box1.height = 5.0;
// box 2 specification
box2.height = 10.0;
// volume of box 1
volume = [box1 volume];
NSLog(@"Volume of Box1 : %f", volume);
// volume of box 2
volume = [box2 volume];
NSLog(@"Volume of Box2 : %f", volume);
[pool drain];
return 0;
}
Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -
2013-09-22 21:25:33.314 ClassAndObjects[387:303] Volume of Box1 : 5.000000
2013-09-22 21:25:33.316 ClassAndObjects[387:303] Volume of Box2 : 10.000000
Özellikleri
Özellikler, sınıfın örnek değişkenine sınıfın dışından erişilebilmesini sağlamak için Objective-C'de tanıtılmıştır.
Özellikler ile başlar @property, bir anahtar kelime olan
Bunu, atomik olmayan veya atomik, salt okunur veya salt okunur ve güçlü, güvenli olmayan, korunmayan veya zayıf erişim tanımlayıcıları izler. Bu, değişkenin türüne göre değişir. Herhangi bir işaretçi türü için güçlü, güvensiz_ tutulmamış veya zayıf kullanabiliriz. Benzer şekilde diğer türler için okuma-yazma veya salt okunur kullanabiliriz.
Bunu, değişkenin veri türü takip eder.
Son olarak, özellik adını noktalı virgülle sonlandırdık.
Uygulama sınıfına sentezleme deyimi ekleyebiliriz. Ancak en son XCode'da, sentez kısmı XCode tarafından halledilir ve sentezleme ifadesini eklemenize gerek yoktur.
Sınıfın örnek değişkenlerine yalnızca özelliklerle erişebiliriz. Aslında, özellikler için dahili olarak alıcı ve ayarlayıcı yöntemler oluşturulur.
Örneğin, bir mülkümüz olduğunu varsayalım @property (nonatomic ,readonly ) BOOL isDone. Kaputun altında, aşağıda gösterildiği gibi oluşturulmuş ayarlayıcılar ve alıcılar vardır.
-(void)setIsDone(BOOL)isDone;
-(BOOL)isDone;
Nesne yönelimli programlamadaki en önemli kavramlardan biri kalıtımdır. Kalıtım, bir sınıfı başka bir sınıf açısından tanımlamamıza olanak tanır ve bu da bir uygulamayı oluşturmayı ve sürdürmeyi kolaylaştırır. Bu aynı zamanda kod işlevselliğini yeniden kullanma ve hızlı uygulama süresi için bir fırsat sağlar.
Bir sınıf oluştururken, tamamen yeni veri üyeleri ve üye işlevler yazmak yerine, programcı yeni sınıfın mevcut bir sınıfın üyelerini miras alması gerektiğini belirleyebilir. Bu mevcut sınıfabase sınıf ve yeni sınıf, derived sınıf.
Kalıtım fikri, is ailişki. Örneğin, memeli IS-A hayvan, köpek IS-A memeli, dolayısıyla köpek IS-A hayvandır vb.
Temel ve Türetilmiş Sınıflar
Objective-C yalnızca çok düzeyli kalıtıma izin verir, yani yalnızca bir temel sınıfa sahip olabilir, ancak çok düzeyli kalıtıma izin verir. Objective-C'deki tüm sınıflar, üst sınıftan türetilmiştir.NSObject.
@interface derived-class: base-class
Temel bir sınıf düşünün Person ve türetilmiş sınıfı Employee aşağıdaki gibi -
#import <Foundation/Foundation.h>
@interface Person : NSObject {
NSString *personName;
NSInteger personAge;
}
- (id)initWithName:(NSString *)name andAge:(NSInteger)age;
- (void)print;
@end
@implementation Person
- (id)initWithName:(NSString *)name andAge:(NSInteger)age {
personName = name;
personAge = age;
return self;
}
- (void)print {
NSLog(@"Name: %@", personName);
NSLog(@"Age: %ld", personAge);
}
@end
@interface Employee : Person {
NSString *employeeEducation;
}
- (id)initWithName:(NSString *)name andAge:(NSInteger)age
andEducation:(NSString *)education;
- (void)print;
@end
@implementation Employee
- (id)initWithName:(NSString *)name andAge:(NSInteger)age
andEducation: (NSString *)education {
personName = name;
personAge = age;
employeeEducation = education;
return self;
}
- (void)print {
NSLog(@"Name: %@", personName);
NSLog(@"Age: %ld", personAge);
NSLog(@"Education: %@", employeeEducation);
}
@end
int main(int argc, const char * argv[]) {
NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];
NSLog(@"Base class Person Object");
Person *person = [[Person alloc]initWithName:@"Raj" andAge:5];
[person print];
NSLog(@"Inherited Class Employee Object");
Employee *employee = [[Employee alloc]initWithName:@"Raj"
andAge:5 andEducation:@"MBA"];
[employee print];
[pool drain];
return 0;
}
Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -
2013-09-22 21:20:09.842 Inheritance[349:303] Base class Person Object
2013-09-22 21:20:09.844 Inheritance[349:303] Name: Raj
2013-09-22 21:20:09.844 Inheritance[349:303] Age: 5
2013-09-22 21:20:09.845 Inheritance[349:303] Inherited Class Employee Object
2013-09-22 21:20:09.845 Inheritance[349:303] Name: Raj
2013-09-22 21:20:09.846 Inheritance[349:303] Age: 5
2013-09-22 21:20:09.846 Inheritance[349:303] Education: MBA
Erişim Kontrolü ve Kalıtım
Türetilmiş bir sınıf, arabirim sınıfında tanımlanmışsa, temel sınıfının tüm özel üyelerine erişebilir, ancak uygulama dosyasında tanımlanan özel üyelere erişemez.
Farklı erişim türlerini, bunlara kimin erişebileceğine göre aşağıdaki şekilde özetleyebiliriz -
Türetilmiş bir sınıf, aşağıdaki istisnalarla tüm temel sınıf yöntemlerini ve değişkenlerini miras alır -
Uygulama dosyasında uzantıların yardımıyla bildirilen değişkenlere erişilemez.
Uygulama dosyasında uzantıların yardımıyla bildirilen yöntemlere erişilemez.
Miras alınan sınıfın yöntemi temel sınıfta uygulaması durumunda, türetilmiş sınıftaki yöntem çalıştırılır.
Kelime polymorphismbirçok biçime sahip olmak anlamına gelir. Tipik olarak, polimorfizm, bir sınıf hiyerarşisi olduğunda ortaya çıkar ve kalıtımla ilişkilendirilir.
Amaç-C polimorfizmi, bir üye işleve yapılan bir çağrının, işlevi çağıran nesnenin türüne bağlı olarak farklı bir işlevin yürütülmesine neden olacağı anlamına gelir.
Örneği düşünün, tüm şekiller için temel arayüzü sağlayan bir Shape sınıfımız var. Kare ve Dikdörtgen, Shape temel sınıfından türetilir.
OOP özelliği hakkında gösterecek olan printArea yöntemimiz var polymorphism.
#import <Foundation/Foundation.h>
@interface Shape : NSObject {
CGFloat area;
}
- (void)printArea;
- (void)calculateArea;
@end
@implementation Shape
- (void)printArea {
NSLog(@"The area is %f", area);
}
- (void)calculateArea {
}
@end
@interface Square : Shape {
CGFloat length;
}
- (id)initWithSide:(CGFloat)side;
- (void)calculateArea;
@end
@implementation Square
- (id)initWithSide:(CGFloat)side {
length = side;
return self;
}
- (void)calculateArea {
area = length * length;
}
- (void)printArea {
NSLog(@"The area of square is %f", area);
}
@end
@interface Rectangle : Shape {
CGFloat length;
CGFloat breadth;
}
- (id)initWithLength:(CGFloat)rLength andBreadth:(CGFloat)rBreadth;
@end
@implementation Rectangle
- (id)initWithLength:(CGFloat)rLength andBreadth:(CGFloat)rBreadth {
length = rLength;
breadth = rBreadth;
return self;
}
- (void)calculateArea {
area = length * breadth;
}
@end
int main(int argc, const char * argv[]) {
NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];
Shape *square = [[Square alloc]initWithSide:10.0];
[square calculateArea];
[square printArea];
Shape *rect = [[Rectangle alloc]
initWithLength:10.0 andBreadth:5.0];
[rect calculateArea];
[rect printArea];
[pool drain];
return 0;
}
Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -
2013-09-22 21:21:50.785 Polymorphism[358:303] The area of square is 100.000000
2013-09-22 21:21:50.786 Polymorphism[358:303] The area is 50.000000
Yukarıdaki örnekte, calculateArea ve printArea yönteminin kullanılabilirliğine göre, temel sınıftaki yöntem veya türetilmiş sınıf çalıştırılır.
Çok biçimlilik, iki sınıfın yöntem uygulamasına dayalı olarak temel sınıf ile türetilmiş sınıf arasındaki yöntemlerin değiştirilmesini yönetir.
Tüm Objective-C programları aşağıdaki iki temel unsurdan oluşur -
Program statements (code) - Bu, programın eylemleri gerçekleştiren kısmıdır ve bunlara yöntem denir.
Program data - Veriler, program işlevlerinden etkilenen program bilgisidir.
Kapsülleme, verileri işleyen verileri ve işlevleri birbirine bağlayan ve hem dış müdahalelerden hem de kötüye kullanımdan koruyan bir Nesne Yönelimli Programlama kavramıdır. Veri kapsülleme, önemli OOP konseptine yol açtı.data hiding.
Data encapsulation verileri ve bunları kullanan işlevleri bir araya getiren bir mekanizmadır ve data abstraction sadece arayüzleri açığa çıkaran ve uygulama detaylarını kullanıcıdan gizleyen bir mekanizmadır.
Objective-C, adı verilen kullanıcı tanımlı türlerin oluşturulması yoluyla kapsülleme ve veri gizleme özelliklerini destekler. classes. Örneğin -
@interface Adder : NSObject {
NSInteger total;
}
- (id)initWithInitialNumber:(NSInteger)initialNumber;
- (void)addNumber:(NSInteger)newNumber;
- (NSInteger)getTotal;
@end
Toplam değişkeni özeldir ve sınıfın dışından erişemeyiz. Bu, programınızın başka herhangi bir bölümü tarafından değil, yalnızca Adder sınıfının diğer üyeleri tarafından erişilebileceği anlamına gelir. Bu, kapsüllemenin elde edilmesinin bir yoludur.
Arayüz dosyası içindeki yöntemlere erişilebilir ve kapsamları geneldir.
Yardımıyla yazılan özel yöntemler vardır. extensionsilerleyen bölümlerde öğreneceğimiz.
Veri Kapsülleme Örneği
Genel ve özel üye değişkenleriyle bir sınıfı uyguladığınız herhangi bir Objective-C programı, veri kapsülleme ve veri soyutlamasına bir örnektir. Şu örneği düşünün -
#import <Foundation/Foundation.h>
@interface Adder : NSObject {
NSInteger total;
}
- (id)initWithInitialNumber:(NSInteger)initialNumber;
- (void)addNumber:(NSInteger)newNumber;
- (NSInteger)getTotal;
@end
@implementation Adder
-(id)initWithInitialNumber:(NSInteger)initialNumber {
total = initialNumber;
return self;
}
- (void)addNumber:(NSInteger)newNumber {
total = total + newNumber;
}
- (NSInteger)getTotal {
return total;
}
@end
int main(int argc, const char * argv[]) {
NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];
Adder *adder = [[Adder alloc]initWithInitialNumber:10];
[adder addNumber:5];
[adder addNumber:4];
NSLog(@"The total is %ld",[adder getTotal]);
[pool drain];
return 0;
}
Yukarıdaki kod derlendiğinde ve yürütüldüğünde, aşağıdaki sonucu verir -
2013-09-22 21:17:30.485 DataEncapsulation[317:303] The total is 19
Yukarıdaki sınıf, sayıları toplar ve toplamı döndürür. Kamu üyeleriaddNum ve getTotal dış dünyaya arayüzler ve kullanıcının sınıfı kullanmak için bunları bilmesi gerekiyor. Özel üyetotal dış dünyadan gizlenmiş, ancak sınıfın düzgün çalışması için gerekli olan bir şeydir.
Strateji Tasarlama
Çoğumuz, onları gerçekten ifşa etmemiz gerekmedikçe, sınıf üyelerini varsayılan olarak özel kılmayı acı deneyimlerle öğrendik. Bu sadece iyiencapsulation.
Objective-C dahil olmak üzere tüm Object-Oriented Programming (OOP) dillerinin temel özelliklerinden biri olduğu için veri kapsüllemeyi anlamak önemlidir.
Bazen, yalnızca belirli durumlarda yararlı olan davranışları ekleyerek mevcut bir sınıfı genişletmek isteyebilirsiniz. Mevcut sınıflara böyle bir uzantı eklemek için Objective-C,categories ve extensions.
Mevcut bir sınıfa, belki de kendi uygulamanızda bir şeyler yapmayı kolaylaştıracak işlevsellik eklemek için bir yöntem eklemeniz gerekiyorsa, en kolay yol bir kategori kullanmaktır.
Bir kategoriyi bildirmek için sözdizimi, standart bir Objective-C sınıf açıklaması gibi @interface anahtar sözcüğünü kullanır, ancak bir alt sınıftan herhangi bir kalıtımı göstermez. Bunun yerine, kategorinin adını şu şekilde parantez içinde belirtir -
@interface ClassName (CategoryName)
@end
Kategorinin özellikleri
Orijinal uygulama kaynak kodunuz olmasa bile herhangi bir sınıf için bir kategori bildirilebilir.
Bir kategoride ilan ettiğiniz herhangi bir yöntem, orijinal sınıfın tüm alt sınıflarının yanı sıra orijinal sınıfın tüm örnekleri için kullanılabilir olacaktır.
Çalışma zamanında, bir kategori tarafından eklenen bir yöntem ile orijinal sınıf tarafından uygulanan bir yöntem arasında hiçbir fark yoktur.
Şimdi örnek bir kategori uygulamasına bakalım. Cocoa sınıfı NSString'e bir kategori ekleyelim. Bu kategori, telif hakkı dizesini döndürmemize yardımcı olan yeni bir getCopyRightString yöntemi eklememizi mümkün kılacaktır. Aşağıda gösterilmiştir.
#import <Foundation/Foundation.h>
@interface NSString(MyAdditions)
+(NSString *)getCopyRightString;
@end
@implementation NSString(MyAdditions)
+(NSString *)getCopyRightString {
return @"Copyright TutorialsPoint.com 2013";
}
@end
int main(int argc, const char * argv[]) {
NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];
NSString *copyrightString = [NSString getCopyRightString];
NSLog(@"Accessing Category: %@",copyrightString);
[pool drain];
return 0;
}
Şimdi programı derleyip çalıştırdığımızda aşağıdaki sonucu alacağız.
2013-09-22 21:19:12.125 Categories[340:303] Accessing Category: Copyright TutorialsPoint.com 2013
Bir kategori tarafından eklenen yöntemler, sınıfın ve alt sınıflarının tüm örnekleri için kullanılabilir olsa da, kategori başlığı dosyasını ek yöntemleri kullanmak istediğiniz herhangi bir kaynak kod dosyasına içe aktarmanız gerekir; aksi takdirde, derleyici uyarıları ve hataları.
Örneğimizde, sadece tek bir sınıfa sahip olduğumuz için, herhangi bir başlık dosyası eklemedik, böyle bir durumda yukarıda belirtildiği gibi başlık dosyalarını dahil etmeliyiz.
Objective-C'de Posing'a başlamadan önce, Posing'ın Mac OS X 10.5'te kullanımdan kaldırıldığını ve bundan sonra kullanılamayacağını bildirmek isterim. Bu nedenle, bu kullanımdan kaldırılmış yöntemler hakkında endişelenmeyenler için bu bölümü atlayabilirsiniz.
Objective-C, bir sınıfın bir programdaki başka bir sınıfı tamamen değiştirmesine izin verir. Yerini alan sınıfın hedef sınıf olarak "poz vereceği" söylenir.
Pozlamayı destekleyen sürümler için, hedef sınıfa gönderilen tüm mesajlar bunun yerine poz sınıfı tarafından alınır.
NSObject, yukarıda belirtildiği gibi mevcut sınıfı değiştirmemizi sağlayan poseAsClass: yöntemini içerir.
Poz Verirken Kısıtlamalar
Bir sınıf, yalnızca doğrudan veya dolaylı üst sınıflarından biri olabilir.
Poz sınıfı, hedef sınıfta bulunmayan herhangi bir yeni örnek değişkenini tanımlamamalıdır (ancak yöntemleri tanımlayabilir veya geçersiz kılabilir).
Hedef sınıf, poz öncesinde herhangi bir mesaj almamış olabilir.
Bir poz sınıfı, süper aracılığıyla geçersiz kılınan yöntemleri çağırabilir, böylece hedef sınıfın uygulamasını birleştirebilir.
Poz sınıfı, kategorilerde tanımlanan yöntemleri geçersiz kılabilir.
#import <Foundation/Foundation.h>
@interface MyString : NSString
@end
@implementation MyString
- (NSString *)stringByReplacingOccurrencesOfString:(NSString *)target
withString:(NSString *)replacement {
NSLog(@"The Target string is %@",target);
NSLog(@"The Replacement string is %@",replacement);
}
@end
int main() {
NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];
[MyString poseAsClass:[NSString class]];
NSString *string = @"Test";
[string stringByReplacingOccurrencesOfString:@"a" withString:@"c"];
[pool drain];
return 0;
}
Şimdi programı daha eski bir Mac OS X'te (V_10.5 veya öncesi) derleyip çalıştırdığımızda, aşağıdaki sonucu alacağız.
2013-09-22 21:23:46.829 Posing[372:303] The Target string is a
2013-09-22 21:23:46.830 Posing[372:303] The Replacement string is c
Yukarıdaki örnekte, uygulamamızla orijinal yöntemi az önce kirlettik ve bu, yukarıdaki yöntemle tüm NSString işlemlerinde etkilenecektir.
Bir sınıf uzantısı, bir kategoriye bir miktar benzerlik taşır, ancak yalnızca derleme zamanında kaynak koduna sahip olduğunuz bir sınıfa eklenebilir (sınıf, sınıf uzantısı ile aynı zamanda derlenir).
Bir sınıf uzantısı tarafından bildirilen yöntemler, orijinal sınıf için uygulama bloğunda uygulanır, bu nedenle, örneğin, NSString gibi bir Cocoa veya Cocoa Touch sınıfı gibi bir çerçeve sınıfında bir sınıf uzantısı bildiremezsiniz.
Uzantılar aslında kategori adı olmayan kategorilerdir. Genellikle şöyle anılıranonymous categories.
Bir uzantıyı bildirmek için sözdizimi, standart bir Objective-C sınıfı açıklaması gibi @interface anahtar sözcüğünü kullanır, ancak bir alt sınıftan herhangi bir kalıtımı göstermez. Bunun yerine, aşağıda gösterildiği gibi sadece parantez ekler -
@interface ClassName ()
@end
Uzantıların özellikleri
Herhangi bir sınıf için bir uzantı bildirilemez, yalnızca kaynak kodun orijinal uygulamasına sahip olduğumuz sınıflar için.
Bir uzantı, yalnızca sınıfa özgü özel yöntemler ve özel değişkenler eklemektir.
Uzantıların içinde bildirilen herhangi bir yöntem veya değişken, devralınan sınıflar için bile erişilebilir değildir.
Uzantı Örneği
Uzantısı olan bir SampleClass sınıfı oluşturalım. Uzantıda, özel değişken internalID'ye sahip olalım.
Ardından, internalID'yi işledikten sonra externalID'yi döndüren getExternalID yöntemine sahip olalım.
Örnek aşağıda gösterilmiştir ve bu çevrimiçi derleyicide çalışmayacaktır.
#import <Foundation/Foundation.h>
@interface SampleClass : NSObject {
NSString *name;
}
- (void)setInternalID;
- (NSString *)getExternalID;
@end
@interface SampleClass() {
NSString *internalID;
}
@end
@implementation SampleClass
- (void)setInternalID {
internalID = [NSString stringWithFormat:
@"UNIQUEINTERNALKEY%dUNIQUEINTERNALKEY",arc4random()%100];
}
- (NSString *)getExternalID {
return [internalID stringByReplacingOccurrencesOfString:
@"UNIQUEINTERNALKEY" withString:@""];
}
@end
int main(int argc, const char * argv[]) {
NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];
SampleClass *sampleClass = [[SampleClass alloc]init];
[sampleClass setInternalID];
NSLog(@"ExternalID: %@",[sampleClass getExternalID]);
[pool drain];
return 0;
}
Şimdi programı derleyip çalıştırdığımızda aşağıdaki sonucu alacağız.
2013-09-22 21:18:31.754 Extensions[331:303] ExternalID: 51
Yukarıdaki örnekte, internalID'nin doğrudan döndürülmediğini görebiliriz. Burada UNIQUEINTERNALKEY'i kaldırıyoruz ve yalnızca kalan değeri getExternalID yöntemi için kullanılabilir hale getiriyoruz.
Yukarıdaki örnek yalnızca bir dizge işlemi kullanır, ancak şifreleme / şifre çözme gibi birçok özelliğe sahip olabilir.
Objective-C, belirli bir durum için kullanılması beklenen yöntemleri açıklayan protokolleri tanımlamanıza izin verir. Protokoller, protokole uygun sınıflarda uygulanır.
Basit bir örnek, bir ağ URL işleme sınıfı olabilir; ağ URL'si getirme işlemi bittikten sonra çağıran sınıfı birleştiren processCompleted delegate yöntemi gibi yöntemlere sahip bir protokole sahip olacaktır.
Aşağıda bir protokol sözdizimi gösterilmektedir.
@protocol ProtocolName
@required
// list of required methods
@optional
// list of optional methods
@end
Anahtar kelimenin altındaki yöntemler @required protokole ve aşağıdaki yöntemlere uyan sınıflarda uygulanmalıdır. @optional anahtar kelime uygulaması isteğe bağlıdır.
İşte protokole uyan sınıf için sözdizimi
@interface MyClass : NSObject <MyProtocol>
...
@end
Bu, MyClass'ın herhangi bir örneğinin yalnızca arabirimde özel olarak bildirilen yöntemlere yanıt vereceği anlamına gelmez, aynı zamanda MyClass'ın MyProtocol'da gerekli yöntemler için uygulamalar da sağladığı anlamına gelir. Sınıf arayüzünde protokol yöntemlerini yeniden açıklamaya gerek yoktur - protokolün benimsenmesi yeterlidir.
Birden fazla protokolü benimsemek için bir sınıfa ihtiyacınız varsa, bunları virgülle ayrılmış bir liste olarak belirtebilirsiniz. Protokolü uygulayan çağıran nesnenin referansını tutan bir delege nesnemiz var.
Aşağıda bir örnek gösterilmiştir.
#import <Foundation/Foundation.h>
@protocol PrintProtocolDelegate
- (void)processCompleted;
@end
@interface PrintClass :NSObject {
id delegate;
}
- (void) printDetails;
- (void) setDelegate:(id)newDelegate;
@end
@implementation PrintClass
- (void)printDetails {
NSLog(@"Printing Details");
[delegate processCompleted];
}
- (void) setDelegate:(id)newDelegate {
delegate = newDelegate;
}
@end
@interface SampleClass:NSObject<PrintProtocolDelegate>
- (void)startAction;
@end
@implementation SampleClass
- (void)startAction {
PrintClass *printClass = [[PrintClass alloc]init];
[printClass setDelegate:self];
[printClass printDetails];
}
-(void)processCompleted {
NSLog(@"Printing Process Completed");
}
@end
int main(int argc, const char * argv[]) {
NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];
SampleClass *sampleClass = [[SampleClass alloc]init];
[sampleClass startAction];
[pool drain];
return 0;
}
Şimdi programı derleyip çalıştırdığımızda aşağıdaki sonucu alacağız.
2013-09-22 21:15:50.362 Protocols[275:303] Printing Details
2013-09-22 21:15:50.364 Protocols[275:303] Printing Process Completed
Yukarıdaki örnekte delgate yöntemlerinin nasıl çağrıldığını ve çalıştırıldığını gördük. StartAction ile başlar, işlem tamamlandıktan sonra, işlemin tamamlandığını belirtmek için processCompleted temsilci yöntemi çağrılır.
Herhangi bir iOS veya Mac uygulamasında, temsilci olmadan uygulanan bir programımız asla olmayacak. Dolayısıyla, delegelerin kullanımını anlıyoruz. Temsilci nesneler, bellek sızıntılarını önlemek için unsafe_unretained özellik türünü kullanmalıdır.
Dinamik bağlama, derleme zamanında yerine çalışma zamanında çağrılacak yöntemi belirlemektir. Dinamik bağlanma ayrıca geç bağlanma olarak da adlandırılır.
Objective-C'de, tüm yöntemler çalışma zamanında dinamik olarak çözümlenir. Yürütülen tam kod, hem yöntem adı (seçici) hem de alan nesne tarafından belirlenir.
Dinamik bağlama, polimorfizmi mümkün kılar. Örneğin, Dikdörtgen ve Kare gibi bir nesne koleksiyonunu düşünün. Her nesnenin kendi printArea yöntemi uygulaması vardır.
Aşağıdaki kod parçasında, [anObject printArea] ifadesi tarafından yürütülmesi gereken gerçek kod çalışma zamanında belirlenir. Çalışma zamanı sistemi, birObject sınıfının hangi sınıfta olursa olsun uygun yöntemi tanımlamak için çalıştırılan yöntemin seçicisini kullanır.
Dinamik bağlamayı açıklayacak basit bir koda bakalım.
#import <Foundation/Foundation.h>
@interface Square:NSObject {
float area;
}
- (void)calculateAreaOfSide:(CGFloat)side;
- (void)printArea;
@end
@implementation Square
- (void)calculateAreaOfSide:(CGFloat)side {
area = side * side;
}
- (void)printArea {
NSLog(@"The area of square is %f",area);
}
@end
@interface Rectangle:NSObject {
float area;
}
- (void)calculateAreaOfLength:(CGFloat)length andBreadth:(CGFloat)breadth;
- (void)printArea;
@end
@implementation Rectangle
- (void)calculateAreaOfLength:(CGFloat)length andBreadth:(CGFloat)breadth {
area = length * breadth;
}
- (void)printArea {
NSLog(@"The area of Rectangle is %f",area);
}
@end
int main() {
Square *square = [[Square alloc]init];
[square calculateAreaOfSide:10.0];
Rectangle *rectangle = [[Rectangle alloc]init];
[rectangle calculateAreaOfLength:10.0 andBreadth:5.0];
NSArray *shapes = [[NSArray alloc]initWithObjects: square, rectangle,nil];
id object1 = [shapes objectAtIndex:0];
[object1 printArea];
id object2 = [shapes objectAtIndex:1];
[object2 printArea];
return 0;
}
Şimdi programı derleyip çalıştırdığımızda aşağıdaki sonucu alacağız.
2013-09-28 07:42:29.821 demo[4916] The area of square is 100.000000
2013-09-28 07:42:29.821 demo[4916] The area of Rectangle is 50.000000
Yukarıdaki örnekte görebileceğiniz gibi, printArea yöntemi çalışma zamanında dinamik olarak seçilir. Dinamik bağlama için bir örnektir ve benzer türdeki nesnelerle uğraşırken birçok durumda oldukça kullanışlıdır.
İçine bir nesne yerleştiren bir sınıfı tanımlayan bir sınıf kümesi içinde alt sınıf oluşturabiliriz. Bu sınıf nesneleri kompozit nesnelerdir.
Dolayısıyla, sınıf kümesinin ne olduğunu merak ediyor olabilirsiniz. Bu yüzden önce sınıf kümesinin ne olduğunu göreceğiz.
Sınıf Kümeleri
Sınıf kümeleri, Foundation çerçevesinin kapsamlı olarak kullandığı bir tasarım modelidir. Sınıf kümeleri, kamuya açık bir soyut üst sınıf altında birkaç özel somut alt sınıfı gruplandırır. Sınıfların bu şekilde gruplandırılması, işlevsel zenginliğini azaltmadan nesne yönelimli bir çerçevenin halka açık mimarisini basitleştirir. Sınıf kümeleri Soyut Fabrika tasarım modeline dayanır.
Basitleştirmek için, benzer işlevler için birden fazla sınıf oluşturmak yerine, girdinin değerine göre işlenmesiyle ilgilenecek tek bir sınıf oluşturuyoruz.
Örneğin, NSNumber'da char, int, bool vb. Gibi birçok sınıf kümemiz var. Hepsini tek bir sınıfta benzer işlemlerle ilgilenen tek bir sınıfta gruplandırıyoruz. NSNumber aslında bu ilkel türlerin değerini nesnelere sarar.
Peki tam olarak bileşik nesne nedir?
Kendi tasarımımız olan bir nesneye özel bir küme nesnesi yerleştirerek, bileşik bir nesne oluşturuyoruz. Bu bileşik nesne, temel işlevi için küme nesnesine güvenebilir, yalnızca bileşik nesnenin belirli bir şekilde işlemek istediği mesajları yakalar. Bu mimari, yazmamız gereken kod miktarını azaltır ve Foundation Framework tarafından sağlanan test edilmiş koddan yararlanmanızı sağlar.
Bu, aşağıdaki şekilde açıklanmaktadır.
Bileşik nesne, kendisini kümenin soyut üst sınıfının bir alt sınıfı olarak bildirmelidir. Bir alt sınıf olarak, üst sınıfın ilkel yöntemlerini geçersiz kılmalıdır. Ayrıca türetilmiş yöntemleri geçersiz kılabilir, ancak bu gerekli değildir çünkü türetilmiş yöntemler ilkel yöntemler aracılığıyla çalışır.
NSArray sınıfının count yöntemi bir örnektir; araya giren nesnenin geçersiz kıldığı bir yöntemi uygulaması şu kadar basit olabilir:
- (unsigned)count {
return [embeddedObject count];
}
Yukarıdaki örnekte, gömülü nesne aslında NSArray tipindedir.
Bir Bileşik Nesne örneği
Şimdi eksiksiz bir örnek görmek için aşağıda verilen Apple belgelerinden örneğe bakalım.
#import <Foundation/Foundation.h>
@interface ValidatingArray : NSMutableArray {
NSMutableArray *embeddedArray;
}
+ validatingArray;
- init;
- (unsigned)count;
- objectAtIndex:(unsigned)index;
- (void)addObject:object;
- (void)replaceObjectAtIndex:(unsigned)index withObject:object;
- (void)removeLastObject;
- (void)insertObject:object atIndex:(unsigned)index;
- (void)removeObjectAtIndex:(unsigned)index;
@end
@implementation ValidatingArray
- init {
self = [super init];
if (self) {
embeddedArray = [[NSMutableArray allocWithZone:[self zone]] init];
}
return self;
}
+ validatingArray {
return [[self alloc] init] ;
}
- (unsigned)count {
return [embeddedArray count];
}
- objectAtIndex:(unsigned)index {
return [embeddedArray objectAtIndex:index];
}
- (void)addObject:(id)object {
if (object != nil) {
[embeddedArray addObject:object];
}
}
- (void)replaceObjectAtIndex:(unsigned)index withObject:(id)object; {
if (index <[embeddedArray count] && object != nil) {
[embeddedArray replaceObjectAtIndex:index withObject:object];
}
}
- (void)removeLastObject; {
if ([embeddedArray count] > 0) {
[embeddedArray removeLastObject];
}
}
- (void)insertObject:(id)object atIndex:(unsigned)index; {
if (object != nil) {
[embeddedArray insertObject:object atIndex:index];
}
}
- (void)removeObjectAtIndex:(unsigned)index; {
if (index <[embeddedArray count]) {
[embeddedArray removeObjectAtIndex:index];
}
}
@end
int main() {
NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];
ValidatingArray *validatingArray = [ValidatingArray validatingArray];
[validatingArray addObject:@"Object1"];
[validatingArray addObject:@"Object2"];
[validatingArray addObject:[NSNull null]];
[validatingArray removeObjectAtIndex:2];
NSString *aString = [validatingArray objectAtIndex:1];
NSLog(@"The value at Index 1 is %@",aString);
[pool drain];
return 0;
}
Şimdi programı derleyip çalıştırdığımızda aşağıdaki sonucu alacağız.
2013-09-28 22:03:54.294 demo[6247] The value at Index 1 is Object2
Yukarıdaki örnekte, dizinin bir işlevini doğrulamanın, normal senaryoda çökmeye neden olacak boş nesnelerin eklenmesine izin vermeyeceğini görebiliriz. Ancak doğrulama dizimiz bununla ilgileniyor. Benzer şekilde, doğrulama dizisindeki her bir yöntem, normal işlem dizisinden ayrı doğrulama süreçleri ekler.
Apple belgelerine başvurursanız, aşağıda verilen Foundation çerçevesinin ayrıntılarını görebilirsiniz.
Temel çerçevesi, Objective-C sınıflarının bir temel katmanını tanımlar. Bir dizi yararlı ilkel nesne sınıfı sağlamanın yanı sıra, Objective-C dili tarafından kapsanmayan işlevselliği tanımlayan birkaç paradigma sunar. Vakıf çerçevesi bu hedefler göz önünde bulundurularak tasarlanmıştır -
Küçük bir temel hizmet sınıfı seti sağlayın.
Serbest bırakma gibi şeyler için tutarlı kurallar getirerek yazılım geliştirmeyi kolaylaştırın.
Unicode dizelerini, nesne kalıcılığını ve nesne dağıtımını destekleyin.
Taşınabilirliği artırmak için bir düzeyde işletim sistemi bağımsızlığı sağlayın.
Çerçeve, Apple tarafından satın alınan NeXTStep tarafından geliştirildi ve bu temel sınıfları Mac OS X ve iOS'un bir parçası oldu.
NeXTStep tarafından geliştirildiği için "NS" sınıf önekine sahiptir.
Tüm örnek programlarımızda Foundation Framework kullandık. Foundation Framework'ü kullanmak neredeyse bir zorunluluktur.
Genellikle şöyle bir şey kullanırız #import <Foundation/NSString.h> Objective-C sınıfını içe aktarmak için, ancak çok fazla sınıfı içe aktarmaktan kaçınmak için tümü #import <Foundation/Foundation.h>.
NSObject, temel kit sınıfları dahil tüm nesnelerin temel sınıfıdır. Bellek yönetimi için yöntemler sağlar. Ayrıca, çalışma zamanı sistemine temel arabirim ve Objective-C nesneleri gibi davranma yeteneği sağlar. Herhangi bir temel sınıfı yoktur ve tüm sınıflar için köktür.
İşlevselliğe dayalı Temel Sınıflar
Sr.No. | Döngü Tipi ve Açıklaması |
---|---|
1 | Veri depolama NSArray, NSDictionary ve NSSet, herhangi bir sınıftaki Objective-C nesneleri için depolama sağlar. |
2 | Metin ve dizeler NSCharacterSet, NSString ve NSScanner sınıfları tarafından kullanılan çeşitli karakter gruplarını temsil eder. NSString sınıfları, metin dizelerini temsil eder ve dizeleri aramak, birleştirmek ve karşılaştırmak için yöntemler sağlar. Bir NSScanner nesnesi, bir NSString nesnesinden sayıları ve kelimeleri taramak için kullanılır. |
3 | Tarihler ve saatler NSDate, NSTimeZone ve NSCalendar sınıfları saatleri ve tarihleri depolar ve takvim bilgilerini temsil eder. Tarih ve saat farklılıklarını hesaplamak için yöntemler sunarlar. NSLocale ile birlikte, tarih ve saatleri birçok formatta görüntülemek ve dünyadaki konuma göre saatleri ve tarihleri ayarlamak için yöntemler sağlarlar. |
4 | İstisna işleme İstisna işleme, beklenmedik durumları ele almak için kullanılır ve NSException ile Objective-C'de sunulur. |
5 | Dosya yönetimi Dosya işleme, NSFileManager sınıfı yardımı ile yapılır. |
6 | URL yükleme sistemi Ortak İnternet protokollerine erişim sağlayan bir dizi sınıf ve protokol. |
Hızlı numaralandırma, bir koleksiyon aracılığıyla numaralandırmaya yardımcı olan bir Objective-C özelliğidir. Bu yüzden hızlı numaralandırma hakkında bilgi sahibi olmak için, önce aşağıdaki bölümde açıklanacak olan koleksiyon hakkında bilgi sahibi olmamız gerekir.
Objective-C'deki Koleksiyonlar
Koleksiyonlar temel yapılardır. Diğer nesneleri tutmak ve yönetmek için kullanılır. Bir koleksiyonun tüm amacı, nesneleri verimli bir şekilde depolamak ve almak için ortak bir yol sağlamasıdır.
Birkaç farklı koleksiyon türü vardır. Hepsi diğer nesneleri tutabilmekle aynı amacı yerine getirirken, çoğunlukla nesnelerin alınma biçiminde farklılık gösterirler. Objective-C'de kullanılan en yaygın koleksiyonlar şunlardır:
- NSSet
- NSArray
- NSDictionary
- NSMutableSet
- NSMutableArray
- NSMutableDictionary
Bu yapılar hakkında daha fazla bilgi edinmek istiyorsanız, lütfen Foundation Framework'teki veri depolamaya bakın .
Hızlı numaralandırma Sözdizimi
for (classType variable in collectionObject ) {
statements
}
İşte hızlı numaralandırma için bir örnek.
#import <Foundation/Foundation.h>
int main() {
NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];
NSArray *array = [[NSArray alloc]
initWithObjects:@"string1", @"string2",@"string3",nil];
for(NSString *aString in array) {
NSLog(@"Value: %@",aString);
}
[pool drain];
return 0;
}
Şimdi programı derleyip çalıştırdığımızda aşağıdaki sonucu alacağız.
2013-09-28 06:26:22.835 demo[7426] Value: string1
2013-09-28 06:26:22.836 demo[7426] Value: string2
2013-09-28 06:26:22.836 demo[7426] Value: string3
Çıktıda görebileceğiniz gibi, dizideki nesnelerin her biri bir sırayla yazdırılır.
Geriye Doğru Hızlı Numaralandırma
for (classType variable in [collectionObject reverseObjectEnumerator] ) {
statements
}
İşte hızlı numaralandırmada reverseObjectEnumerator için bir örnek.
#import <Foundation/Foundation.h>
int main() {
NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];
NSArray *array = [[NSArray alloc]
initWithObjects:@"string1", @"string2",@"string3",nil];
for(NSString *aString in [array reverseObjectEnumerator]) {
NSLog(@"Value: %@",aString);
}
[pool drain];
return 0;
}
Şimdi programı derleyip çalıştırdığımızda aşağıdaki sonucu alacağız.
2013-09-28 06:27:51.025 demo[12742] Value: string3
2013-09-28 06:27:51.025 demo[12742] Value: string2
2013-09-28 06:27:51.025 demo[12742] Value: string1
Çıktıda görebileceğiniz gibi, dizideki nesnelerin her biri yazdırılır, ancak normal hızlı numaralandırmaya kıyasla ters sırada.
Bellek yönetimi, herhangi bir programlama dilinde en önemli süreçlerden biridir. Gerektiğinde nesnelerin belleğinin tahsis edildiği ve artık gerekmediğinde ayrıldıkları süreçtir.
Nesne belleğini yönetmek bir performans meselesidir; bir uygulama gereksiz nesneleri serbest bırakmazsa, bellek ayak izi büyür ve performansı düşer.
Objective-C Bellek yönetimi teknikleri genel olarak iki türe ayrılabilir.
- "Manuel Tutma Bırakma" veya MRR
- "Otomatik Referans Sayma" veya ARC
"Manuel Tutma Bırakma" veya MRR
MRR'de, nesneleri kendi başımıza takip ederek belleği açıkça yönetiriz. Bu, NSObject Foundation sınıfının çalışma zamanı ortamıyla birlikte sağladığı referans sayma olarak bilinen bir model kullanılarak uygulanır.
MRR ve ARC arasındaki tek fark, alıkoyma ve bırakma işlemlerinin bizim tarafımızdan elle yapılırken, ikincisinde otomatik olarak halledilmesidir.
Aşağıdaki şekil, bellek yönetiminin Objective-C'de nasıl çalıştığına dair bir örneği temsil etmektedir.
A Sınıfı nesnenin bellek yaşam döngüsü yukarıdaki şekilde gösterilmektedir. Gördüğünüz gibi, tutma sayısı nesnenin altında gösterilir, bir nesnenin alıkoyma sayısı 0 olduğunda, nesne tamamen serbest bırakılır ve diğer nesnelerin kullanması için belleği serbest bırakılır.
A Sınıfı nesne ilk olarak NSObject'te bulunan tahsis / init yöntemi kullanılarak oluşturulur. Şimdi, tutma sayısı 1 olur.
Şimdi, B sınıfı, A Sınıfı Nesnesini korur ve A Sınıfı nesnesinin tutma sayısı 2 olur.
Daha sonra, C Sınıfı nesnenin bir kopyasını oluşturur. Şimdi, örnek değişkenleri için aynı değerlerle A Sınıfının başka bir örneği olarak oluşturulur. Burada tutma sayısı 1'dir ve orijinal nesnenin tutma sayısı değildir. Bu, şekildeki noktalı çizgi ile temsil edilmektedir.
Kopyalanan nesne, serbest bırakma yöntemi kullanılarak Sınıf C tarafından serbest bırakılır ve tutma sayısı 0 olur ve dolayısıyla nesne yok edilir.
İlk A Sınıfı Nesne durumunda, alıkoyma sayısı 2'dir ve imha edilmesi için iki kez serbest bırakılması gerekir. Bu, tutma sayısını sırasıyla 1 ve 0'a düşüren Sınıf A ve Sınıf B'nin serbest bırakma beyanları ile yapılır. Sonunda nesne yok edilir.
MRR Temel Kuralları
Oluşturduğumuz herhangi bir nesneye sahibiz: Adı "tahsis", "yeni", "kopya" veya "mutableCopy" ile başlayan bir yöntemi kullanarak bir nesne oluştururuz.
Saklama kullanarak bir nesnenin sahipliğini alabiliriz: Alınan bir nesnenin normalde alındığı yöntem dahilinde geçerliliğini koruması garanti edilir ve bu yöntem aynı zamanda nesneyi güvenli bir şekilde çağıran kişiye geri döndürebilir. Muhafazayı iki durumda kullanırız -
Bir erişimci yönteminin veya bir init yönteminin uygulanmasında, bir nesnenin sahipliğini almak için bir özellik değeri olarak depolamak istiyoruz.
Bir nesnenin başka bir işlemin yan etkisi olarak geçersiz kılınmasını önlemek için.
Artık ona ihtiyacımız kalmadığında, sahip olduğumuz bir nesnenin sahipliğini bırakmalıyız: Bir nesnenin sahipliğini, ona bir sürüm mesajı veya bir otomatik bırakma mesajı göndererek bırakırız. Cocoa terminolojisinde, bir nesnenin sahipliğinden vazgeçme bu nedenle tipik olarak bir nesneyi "serbest bırakmak" olarak adlandırılır.
Sahip olmadığınız bir nesnenin mülkiyetinden vazgeçmemelisiniz: Bu, açıkça ifade edilen önceki politika kurallarının sadece bir sonucudur.
#import <Foundation/Foundation.h>
@interface SampleClass:NSObject
- (void)sampleMethod;
@end
@implementation SampleClass
- (void)sampleMethod {
NSLog(@"Hello, World! \n");
}
- (void)dealloc {
NSLog(@"Object deallocated");
[super dealloc];
}
@end
int main() {
/* my first program in Objective-C */
SampleClass *sampleClass = [[SampleClass alloc]init];
[sampleClass sampleMethod];
NSLog(@"Retain Count after initial allocation: %d",
[sampleClass retainCount]);
[sampleClass retain];
NSLog(@"Retain Count after retain: %d", [sampleClass retainCount]);
[sampleClass release];
NSLog(@"Retain Count after release: %d", [sampleClass retainCount]);
[sampleClass release];
NSLog(@"SampleClass dealloc will be called before this");
// Should set the object to nil
sampleClass = nil;
return 0;
}
Yukarıdaki programı derlediğimizde aşağıdaki çıktıyı alacağız.
2013-09-28 04:39:52.310 demo[8385] Hello, World!
2013-09-28 04:39:52.311 demo[8385] Retain Count after initial allocation: 1
2013-09-28 04:39:52.311 demo[8385] Retain Count after retain: 2
2013-09-28 04:39:52.311 demo[8385] Retain Count after release: 1
2013-09-28 04:39:52.311 demo[8385] Object deallocated
2013-09-28 04:39:52.311 demo[8385] SampleClass dealloc will be called before this
"Otomatik Referans Sayma" veya ARC
Otomatik Referans Sayma veya ARC'de, sistem MRR ile aynı referans sayma sistemini kullanır, ancak uygun bellek yönetimi yöntemini bizim için derleme zamanında çağırır. Yeni projeler için ARC'yi kullanmamız şiddetle tavsiye edilir. ARC kullanırsak, bu belgede açıklanan temel uygulamayı anlamaya genellikle gerek kalmaz, ancak bazı durumlarda yardımcı olabilir. ARC hakkında daha fazla bilgi için bkz . ARC Sürüm Notlarına Geçiş.
Yukarıda belirtildiği gibi, ARC'de, derleyici tarafından halledileceği için sürüm ve tutma yöntemlerini eklememiz gerekmez. Aslında, Objective-C'nin altında yatan süreç hala aynı. Saklama ve bırakma işlemlerini dahili olarak kullanır ve geliştiricinin bu işlemler hakkında endişelenmeden kod yazmasını kolaylaştırır, bu da hem yazılan kod miktarını hem de bellek sızıntısı olasılığını azaltır.
MRR ile birlikte Mac OS-X'te kullanılan çöp toplama adı verilen başka bir ilke vardı, ancak OS-X Mountain Lion'da kullanımdan kaldırıldığından beri MRR ile birlikte tartışılmadı. Ayrıca, iOS nesneleri hiçbir zaman çöp toplama özelliğine sahip değildi. Ve ARC ile OS-X'te de çöp toplama kullanımı yoktur.
İşte basit bir ARC örneği. ARC'yi desteklemediği için bunun çevrimiçi derleyicide çalışmayacağını unutmayın.
#import <Foundation/Foundation.h>
@interface SampleClass:NSObject
- (void)sampleMethod;
@end
@implementation SampleClass
- (void)sampleMethod {
NSLog(@"Hello, World! \n");
}
- (void)dealloc {
NSLog(@"Object deallocated");
}
@end
int main() {
/* my first program in Objective-C */
@autoreleasepool {
SampleClass *sampleClass = [[SampleClass alloc]init];
[sampleClass sampleMethod];
sampleClass = nil;
}
return 0;
}
Yukarıdaki programı derlediğimizde aşağıdaki çıktıyı alacağız.
2013-09-28 04:45:47.310 demo[8385] Hello, World!
2013-09-28 04:45:47.311 demo[8385] Object deallocated