ვიკიპედია

Objective-C


Objective-C — ამრეკლავი, ობიექტზე-ორიენტირებული პროგრამირების ენა, რომელიც C-ს უმატებს Smalltalk-ის ნაირ მესეჯების გაგზავნის მექანიზმს.

Objective-C
პარადიგმა ამრეკლავი, ობიექტზე-ორიენტირებული
გამოქვეყნების თარიღი 1986
შემქმნელი ბრად კოქსი, ტომ ლოვი
კომპანია Apple Inc.
ტიპების განსაზღვრა სტატიკური, დინამიკური, სუსტი
მთავარი ვერსიები GCC, Apple
ენების გავლენით Smalltalk, C
ენებზე ზეგავლენა TOM, Java, Objective-J

დღევანდელ დღეს იგი უმთავრესად გამოიყენება Apple-ის Mac OS X-სთვის და iPhone OS-თვის: მაინც თუ არ ეყრდობიან OpenStep სტანდარტს. Objective-C არის Cocoa API-ის მთავარი პროგრამირების ენა, მაინც თუ იგი გამოყენებული იყო NeXT-ის NeXTSTEP OS-ის მთავარ ენად. ზოგადი Objective-C პროგრამები რომლებიც არ ხმარობემ ამ ბიბლიოთეკებს შესაძლოა კომპილირებული იყვნენ ნებისმიერი GCC კომპილატორით (რომელიც Objective-C კომპილატორს შეიცავს) მხარდაჭერილ ოპერაციულ სისტემაში.

ისტორია რედაქტირება

1980 წლებში, პროგრამების შექმნის მიღებული მეთოდი იყო სტრუქტურული პროგრამირება. სტრუქტურული პროგრამირება, პროგრამების პატარა ნაწილებად დაყოფვას ადვიელებს, რომ დიდ პროგრამებზე მუშაობა საკმაოდ ადვილი დარჩეს. მაგრამ რახან პროგრამების მოცულობა იზდებოდა და იზდებოდა სტრუქტურული პროგრამირება საკმარისი აღარ იყო, სამაგიროდ იწერებოდა უფრო მეტი და მეტი პროცედურები (ფუნქციები), რაც პროგრამების კოდს ართულებდა და ამავე დროს კოდის ხელმეორედ გამოყენების უნარს.

ობიექტზე-ორიენტირებულ პროგრამირებაში ბევრი ხედავდა ამ პრობლემების მოგვარების საშუალებას. სიმართლე რომ ვთაქათ, Smalltalk-ს ამ პრობლემების უმრავლესი პუნქტი უკვე მოგვარებული ჰქონდა; მსოფლიოში არსებული ზოგიერთი ყველაზე კომპლექსური სისტემები Smalltalk-ში იყო დაწერილი.

ნაკლისი ის იყო რომ Smalltalk-ი ხმარობდა ვირტუალურ მანქანას. ვირტუალური მანქანა მუშაობდა თავისივე მეხსიერების მექანიზმით (არქივით), რომელიც შეიცავდა პროგრამირების ხელსაწყოებს. Smalltalk-ის მეხსიერების არქივი იყო ძალიან დიდი და დიდი რაოდენობის მეხსიერებას მოითხოვდა მაშინდელი დროისთვის და მაშასადამე ნელიც იყო.

Objective-C არის შექმნილი უპირატეს ყოვლივ ბრად კოქსის და ტომ ლოვის მიერ, მათ კომპანია Stepstone-ში 1980-იან წლებში. ორივე გაეწნო Smalltalk-ს როდესაც ისინი 1981 წელს იყვნენ ITT Corporation’s Programming Technology Center-ში კოქსი დაინტერესდა არსებული კოდის ხელახლა გამოყენების პრობლემებით. იგი დარწმუნდა რომ ენა როგორიცაა Smalltalk-ი არა ეფექტიანი აღმოჩდებოდა ITT-ს სისტემირი პროგრამისტებისთვის. კოქსმა წამოიწყო C კომპილატორში წვლილებების შეტანა რომ Smalltalk-ის ზოგიერთი შესაძლებლობა დაემატებინა. მან მალე მიიღო გამოსაყენი ვერსია რომელსაც C-სთან ერთად ჰქონდა დამატებული ობიექტზე-ორიენტირებული საპორგრამო შესაძლებლობები, რომელსაც დაარქვა "OOPC" (Object-Oriented Programming in C). ამასობაში, 1982 წელს, ლოვი აიყვანეს Schlumberger Research-ში და მას შესაძლებლობა მიეცა რომ პირველი Smalltalk-80-ის კომერციული ვერსია ეშოვა, რაც მის გამოგონებაზე ზეგავლენა მოახდინა.

ლოვმა და კოქსმა დააარსეს მათი კომპანია, Productivity Products International (PPI), რომ გაეყიდათ მათი პროდუქტი, რომელსაც მოყვებოდა Objective-C-ის კომპილატორი, ძლიერი კლასების ბიბლიოთეკებით.

1986 წელს, კოქსმა გამოაქვეყნა Objective-C მთავარი აღწერა მის ორიგინალურ ფორმაში წიგნში, Object-Oriented Programming, An Evolutionary Approach.

მიუხედავად იმისა რომ მან ხაზი გაუსვა იმას რომ კოდის ხელმეორედ გამოყენების პრობლების გადაწყვეტისთვის ენაზე მეტია საჭირო, Objective-C ხშირად აღმოჩდა შედარებული სხვა ენებთან მხოლოდ შესაძლებლობების ფონზე.

პოპულარობა NeXT-ის მეშვეობით რედაქტირება

Apple-ის დატოვების შემდეგ, სტივ ჯობმა დააარსა კომპანია NeXT-ი. 1988 წელს, NeXT-მა მიიღო Objective-Cის ლიცენზია StepStone-იდან (Objective-C trademark-ის მფლობელი) და გამოუშვა თავისი Objective-Cის კომპილატორი და ბიბლიოთეკები რომლებზეც დაყრდნიბილი იყვნენ NeXTstep-ის გრაფიკული ინტერფეისი და Interface Builder-ი. მიუხედავად იმისა რომ NeXT workstation-ებმა კომერციულ წარმატებას ვერ მიახწიაეს, ხელსაწყოებს კი პოპულარულნი გახდნენ ინდუსტრიაში. ამან განაპირობა NeXT-ის მიერ მოწყობილობების შექმნის გაუქმება და ყურადღების გადატანა მის ნაწარმოებ პროგრამებზე; NeXTstep (და OpenStep-ის) გაყიდვა როგორც პროგრამირების პლატფორმა.

GNU პროექტმა დაიწყო მუშაობა მის უფასი და თავისუფალ NeXTStep-ის კლონზე, სახელად GNUstep, რომელიც იცავს OpenStep-ის სტანდარტს. დენის გლატინგმა დაწერა პირველი gnu-objc runtime-ი 1992 წელს. Objective-Cის runtime-ი რომელიც იხმარებაა 1993 წლიდან არის დაწერილი კრესტენ კრაბ თორუპის მიერ როცა იგი დანიაში უნივერსიტეტის სტუდენტი იყო. კრესტენმა აგრეთვე იმუშავა NeXT-ში 1993-დან 1996-მდე.

NeXT-ის ყიდვის (1996 წელს) შემდეგ , Apple-მა გამოიყენა OpenStep-ი თავის ახალ ოპერაციულ სისტემისთვის, Mac OS X. ამაში შედიოდა Objective-C და NeXT-ის Objective-Cში პროგრამების დასაწერი ხელსაწყოები, Project Builder (შემდეგში შეცვლილი Xcode-ის მიერ), და აგრეთვე გრაფიკული ინტერფეისის შექმნის ხელსაწყო, Interface Builder. Apple-ის დღევანდელი დღის უმეტესი Cocoa API-ს ნაწილი არის დაყრდნობილი OpenStep-ის ინტერფეისის ობიექტებზე, და წარმოადგენს Objective-Cს ყველაზე დიდ ნაწილს რომელიც გამოიყენება პროგრამირებისთვის.

სინტაქსი რედაქტირება

Objective-C არის ძალიან thin C-ის ზედა ფენა, არის C-ზე დამატებული საშუალებები. ასე რომ, შესაძლოა ნებისმიერი C კოდის კომპილირება Objective-C კომპილერით, და C კოდის შერწყმა Objective-C კლასთან.

Objective-Cის სინტაქსი მოდის Smalltalk-იდან. არა ობიექტზე-ორიენტირებული ოპერაციების სინტაქსი (ცვლადები, ინსტრუქციები, ფუნქციის აღწერა, ფუნქციის გამოყენება) არის იგივე რაც C-ში, და ობიექტზე-ორიენტირებული ოპერაციების სინტაქსი მიბაძულია Smalltalk-ის მესეჯების გაგაზავნის სისტემასთან.

მესეჯები რედაქტირება

Objective-Cის ობიექტზე-ორიენტირებული პროგრამირების მოდელი არის ბაზირებული მესეჯების სხვა ობიექტების ნიმუშებთან გაგზავნაზე. Simula-ს პროგრამირების სტილი, რომელიც გამოყენებულია C++ში, სემანტიკურად ხაზგასმით განსხვავდება. Objective-Cში მეთოდემის დაძახება არ ხდემა, არამედ მათ უგზავნით მესეჯებს, ეს კონცეფტი განლაგებს თუ როგორ სრულდება მეთოდის კოდის შესრულება. Simula-ს ნაირ ენაში, მეთოდის სახელი, უმეტეს შემთხვევაში, არის შერწყმული აღნიშნული კლასის კოდის სექციაში, კომპილატორის მიერ, მაგრამ Smalltalk-ში და Objective-Cში, მესეჯი წარმოადგენს მხოლოდ სახელს, რომელიც არის დადგენილი პროგრამის მუშაობის დროს: მესეჯის განმარტება (interpretation) ექვამდებარება მიმღებ ობიექტს. აქედან გამომდინარე, მესეჯების გაგზავნის მექანიზმი არ არის დამოკიდებული რომ ცვლადების ტიპები შეამოწმოს: ომიექტი რომლისთვისაც მესეჯი არის გამოგზავნილი (მოიხსენება როგორც მიმღები) არ იძლევა გარანტიას რომ იგი მესეჯს პასუხს გასცემს, და მაგ შემთხვევაში იგ იგნორირებს და ნულ მითითემას (NULL pointer) აბრუნებს.

obj ობიექტისტვის მესეჯის გაგზავნა C++ში მოითხოვს შემდეგ კოდს: 

  obj->method(parameter);

რომელიც Objective-Cში იწერება როგორც შემდეგ: 

  [obj method:parameter];

ორივე პროგრამირების სტილს მიაჩნია თავისი პლიუსები და მინუსები. Simula-ს ნაირი ობიექტზე-ორიენტირება მრავალ მემკვიდრეობას და კოდის ჩქარ შესრულებას უმართავს ხელს კომპილირების დროს ინფორნმაციების შეერთებით სადაც შესაძლოა მაგრამ არ აქვს დინამიური შერწყმის უნარი (ბრუნებრივ შემთხვევაში). იგი აგრეთვე იძულებულს ხდის რომ ყოველივე მეთოდს ჰქონდეს მისი იმპლემენტაცია გარდა იმ შემთხვევაში თუ იგი ვირტუალურია, (იმპლემენტაცია მაინც საჭიროა რომ მეთოდის მოხმარება შეიძლებოდეს). Smalltalk-ის ნაირი ობიექტზე-ორიენტირება კი უშვებს მესეჯების გაგზავნას, რაც ანიჭებს დინამიურობას. მესეჯის გაგზავნის მექანიზმი არ ხდის აუცილებელს რიმ გარკვეული ობიექტი აღწერილი იყოს კომპილირების დროს. (ტიპის დინამიკურად მინიჭების შესახემ ქვემოთ იხილეთ ნუთუ რა უპირატესობა მოაქვს მას დინამიური შერწმის მეშვეობით).

უნდა შევნიშნოთ რომ, მესეჯების გარკვევის დროის გამო Objective-Cს მესეჯების გაგზავნა და მიყება მინიმუმ სამჯერ უფრო ნელია ვიდრე C++ის ვირტუალური მეთოდის გამოყენებით.[1]

ინტერფეისები და იმპლემენტაციები რედაქტირება

Objective-C აიძულებს პროგრამისტს რონ კლასის ინტერფეისი და იმპლემენტაცია იყოს დაყოფილი კოდის სხვადასხვა ბლოკსი. მიღებული წესის მიხედვით, ინტერფეისი არის დაწერილი თავ ფაილში (header) (გაფართოება .h) და იმპლემენტაცია კი კოდის ფაილში (გაფართოება .m).

ინტერფეისი რედაქტირება

უმრავლეს შემთხვევაში, კლასის ინტერფეისი არის აღწერილი თავ ფაილში (header file). მიღებული წესის მიხედვით თავ ფაილის (header file) სახელი არის კლასის სახელი.

ამ შემთხვევაში Class კლასის თავ ფაილის (header file) სახელი იქნება Class.h

ინტერფეისის იყებს ასეთ ფორმას: 

@interface classname : superclassname {
    // instance variables
}
+classMethod1;
+(return_type)classMethod2;
+(return_type)classMethod3:(param1_type)parameter_varName;
 
-(return_type)instanceMethod1:(param1_type)param1_varName :(param2_type)param2_varName;
-(return_type)instanceMethod2WithParameter:(param1_type)param1_varName andOtherParameter:(param2_type)param2_varName;
@end

ნიშანი "+" ანიშნებს კლასის მეთოდს, "-" კი კლასის ნიმუშის მეთოდს. კლასის მეთოდებს კლასის ნიმუშის ცვლადებთან მიღვწვდომა არა აქვთ.

C++ში თუ გადავთარმნით ზემოთ მოცემულ კოდს იგი უდრის: 

class classname : superclassname {
  // instance variables
 
  // Class (static) functions
  static void* classMethod1();
  static return_type classMethod2();
  static return_type classMethod3(param1_type parameter_varName);
 
  // Instance (member) functions
  return_type instanceMethod1(param1_type param1_varName, param2_type param2_varName);
  return_type instanceMethod2WithParameter(param1_type param1_varName, param2_type param2_varName=default);
};

შეამჩნიეთ რომ instanceMethod2WithParameter წარმოადგენს Objective-Cის დასახელებული პარამეტრის (named parameter) შესაძლებლობას რომელიც არ არსებობს C/C++ში.

დაბრუნული ცვლადის ტიპი შესაძლოა იყოს ნებისმიერი C-ს ტიპი, მითითება Objective-Cს ზოგად ობიექტთან, ან მითითება სპეციფიკურ ტიპთან როგორიცაა NSArray *, NSImage *, or NSString *. ბრუნებრივ შემთხვევაში დაბრუნული ცვლადის ტიპი არის ზოგადი Objective-Cის ტიპი რომელიცაა id.

მეთოდის არგუმენტების წინ არის ორი წერტილი (":") და შემდეგ არგუმენტის ტიპი ფრჩხილებში და ბილოს მოდის მეთოდის არგუმენტის სახელი. ზოგიერთ შემთხვევაში (სისტემური API-ის წერის დროს) პრაქტიკულია ტექსტუალური აღწერის დამატება ყოველივე პარამეტრის წინ. 

-(void) setRange:(int)start :(int)end;
-(void) importDocumentWithName:(NSString *)name withSpecifiedPreferences:(Preferences *)prefs beforePage:(int)insertPage;

იმპლემენტირება რედაქტირება

ინტერფეისი მარტო აღნიშნავს კლასის ინტერფეისს და არა თვითონ მეთოდებს; მთავარი კოდი იწერება იმპლემეტირების დროს. იმპლემენტირების ფაულების გაფართოება არის .m. 

@implementation classname
+classMethod {
    // implementation
}
-instanceMethod {
    // implementation
}
@end

მეთოდები აწერებიან თავიანთი ინტერფეისის აღწერის მიხედვით. Objective-Cს და Cს შედარება: 

-(int)method:(int)i {
    return [self square_root: i];
}

int function(int i) {
    return square_root(i);
}

სინტაქსი ხელს უწყობს პარამეტრების პსევდო-დასახელებას. 

-(int)changeColorToRed:(float)red green:(float)green blue:(float)blue
 
[myColor changeColorToRed:5.0 green:2.0 blue:6.0];

შინგნით როგორ არის მეთოდი აღწერილი დამოკიდებულია Objective-C ვერსიაზე. თუ myColor არის Color კლასის ნიმუში, შიგნით, ნიმუშის მეთოდს -changeColorToRed:green:blue: შეიძლება ერქვას _i_Color_changeColorToRed_green_blue. ეს i უთითებს კლასის ნიმუშის მეთოდს, კლასის და მეთოდის სახელი ერთად შეერთებული, ორი წერტილი კი ქვედახაზად გადაიქცა. რახან პარამეტრის რიგითი ადგილობა შედის მეთოდის სახელის ნაწილში, პარამეტრების წყობას ვერ შეცვლით რომ თავენი პროგრამირების სტილს შეეფეროს როგორც ნამდვილი დასახელებული პარამეტრებით.

მაგრამ, შიდა ფენაში მეთოდის აღწერილი სახელი იშვიათად გამოიყენება, და უმეტეს შემთხვევაში მესეჯების მექანიზმით (Objective-C runtime ბიბლიოთეკის მიხედვით) იხმარება მეთოდები - რომელი მეთოდის დაძახება მოხდება აუცილებელი არაა ცნობილი პროგრამის შერწყმის დროს (link time): მიმღები კლასი (რომელიც მესეჯს იღებს) პროგრამის მოქმედების დროს იგებს.

ნიმუშის შექმნა რედაქტირება

როცა Objective-Cში კლასი დაწერილია, მისი ნიმუშის შექმნა შესაძლო ხდება. ეს ხდება ახალი ობიექტისთვის საკმარისი მეხსიერების ნაყოფის მიცემით და მისი მონაცემის მინიჭებით. სანამ ეს ორი ეტაპი არ არის გავლილი ობიექტი ვერ იმოქმედებს. ეს ტიპურად ერ ხაზი კოდით ხდება: 

MyObject * o = [[MyObject alloc] init];

alloc-ის დაძახებით ვაძლევთ საკმარის მეხსიერებას რომ მისი ნიმუშის ცვლადების გამოყენება შიეძლებოდეს, შემდეგ შესაძლოა რომ init მეთოდი სხვანაირადაც იყოს დაწერილი რიმ მან სხვა მონაცემები მიანიჭოს კლასის ნიმუშს. init მეთოდი ხშირად ასე იწერება: 

-(id) init {
    self = [super init];
    if (self) {
        ivar1 = value1;
        ivar2 = value2;
        .
        .
        .
    }
    return self;
}

პროტოკოლები რედაქტირება

Objective-C იქნა დახვეწილი NeXT კომპანიაში,მას დაემატა მრავალი მემკვიდრების მხარდეჭერა სპეციფიკაციის დროს და არა იმპლემენტაციის დროს (ობიექტზე პროგრამირების კონცეპტი), პროტოკოლების დაარსებით.ეს არის როგორც C++-ის მრავალ მემკვიდრეობიანი ფუძე კლასი ან როგორც ჯავას ან C#-ის ინტერფეისი "interface". Objective-C იყენებს სპეციალურად შექმნილ პროტოკოლებს, რომლებსაც ეწოდება არაფორმალური პროტოკოლი (informal protocols), ან კომპილატორის მეშვეობით შექმნილი პროტოკოლი რომელსაც ეწოდება ფორმალური პროტოკოლი (formal protocols).

რესურსები ინტერნეტში რედაქტირება

მოძიებულია „https://ka.wikipedia.org/w/index.php?title=Objective-C&oldid=4455642“-დან