Ziel c

Ziel c ist ein allgemeiner Zweck, objektorientierter Programmiersprache Das fügt hinzu Smalltalk-Stil Nachrichten zum C Programmiersprache. Ursprünglich von Brad Cox und Tom Love in den frühen 1980er Jahren entwickelt, wurde es von ausgewählt von Nächste für seine Nächster Schritt Betriebssystem. Objective-C war die Standard-Programmiersprache, die von unterstützt wurde Apfel Für die Entwicklung Mac OS (die von NextStep herabstieg^[3]) und iOS Anwendungen, die ihre jeweils anwenden Anwendungsprogrammierschnittstellen (APIS), Kakao und Kakao -Berührungbis zur Einführung von Schnell im Jahr 2014.^[4]

Objektiv-C Plattform unterstützt durch GNU GCC oder Llvm/Klang.

Programmdateien von Objective-C-Quellcode 'Messaging/Implementierung' haben normalerweise in der Regel .m Dateiname-Erweiterungen, während Objective-C-Header/Schnittstellendateien haben .h Erweiterungen, die gleiche wie C Header -Dateien. Objektiv-C ++-Dateien werden mit a bezeichnet .mm Dateierweiterung.

Geschichte

Objective-C wurde hauptsächlich durch erstellt Brad Cox und Tom Love in den frühen 1980er Jahren in ihrer Firma Produktivitätsprodukte International (PPI).^[5]

Vor der Schaffung ihres Unternehmens wurden beide eingeführt worden Smalltalk während bei ITT CorporationDas Programmierungstechnologiezentrum im Jahr 1981. Die früheste Arbeit an Objective-C führt ungefähr zu dieser Zeit zurück.^[6] Cox war fasziniert von Problemen der wahren Wiederverwendbarkeit in Software-Design und Programmierung. Er erkannte, dass eine Sprache wie SmallTalk für den Aufbau von Entwicklungsumgebungen für Systementwickler bei ITT von unschätzbarem Wert ist. Er und Tom Love erkannten jedoch auch, dass die Abwärtskompatibilität mit C für das Telekommunikations -Ingenieurstudium von ITT von entscheidender Bedeutung war.^[7]

Cox begann einen Vorprozessor zu schreiben C einige der Fähigkeiten von SmallTalk hinzuzufügen. Er hatte bald eine funktionierende Implementierung einer objektorientierten Erweiterung auf die C Sprache, die er "OOPC" für objektorientierte Vorkompiler nannte.^[8] Love wurde 1982 von Schlumberger Research eingestellt und hatte die Möglichkeit, die erste kommerzielle Kopie von SmallTalk-80 zu erwerben, die die Entwicklung ihrer Idee weiter beeinflusste. Um zu demonstrieren, dass echte Fortschritte erzielt werden könnten, zeigte Cox, dass austauschbar gemacht werden kann Softwarekomponenten Wirklich benötigten nur wenige praktische Änderungen an vorhandenen Tools. Insbesondere mussten Objekte auf flexible Weise unterstützt, mit einem verwendbaren Bibliothekssatz geliefert und den Code (und alle vom Code benötigten Ressourcen) in ein plattformatiges Format gebündelt werden.

Love und Cox bildeten schließlich PPI, um ihr Produkt zu kommerzialisieren, das einen Objektiv-C-Compiler mit Klassenbibliotheken gekoppelt hat. 1986 veröffentlichte Cox die Hauptbeschreibung von Objective-C in seiner ursprünglichen Form im Buch Objektorientierte Programmierung, ein evolutionärer Ansatz. Obwohl er darauf hinwies, dass das Problem der Wiederverwendbarkeit mehr als nur das, was Objective-C bietet, ist die Sprache häufig mit der Funktion für Funktionen mit anderen Sprachen verglichen.

Popularisierung durch nächstes

1988,, Nächste lizenziertes Ziel-C aus Stepstone (der neue Name des PPI, des Eigentümers der Objektiv-C-Marke) und erweiterte die GCC Compiler zur Unterstützung von Ziel-C. Als nächstes entwickelte Appkit und Foundation Kit Bibliotheken, auf denen die Nächster Schritt Die Benutzeroberfläche und der Schnittstellenbauer basieren basiert. Während die nächsten Arbeitsstationen auf dem Markt keinen großen Einfluss hatten, wurden die Tools in der Branche weithin gelobt. Dies führte neben der Drop -Hardwareproduktion und dem Fokus auf Softwaretools, den Verkauf von NextStep (und OpenStep) als Plattform für benutzerdefinierte Programme.

Um die Bedingungen der GplAls nächstes hatte ich ursprünglich beabsichtigt, das Objective-C-Frontend separat zu versenden, sodass der Benutzer ihn mit GCC verknüpfen konnte, um den ausführbaren Compiler zu erstellen. Obwohl ursprünglich akzeptiert von Richard M. StallmanDieser Plan wurde abgelehnt, nachdem Stallman die Anwälte von GNU konsultiert und als nächstes zugestimmt hatte, objektiv-C-Teil von GCC zu sein.^[9]

Die Arbeit zu verlängern GCC wurde von Steve Naroff geleitet, der als nächstes von Stepstone teilnahm. Die Compiler -Änderungen wurden gemäß der Ermittlung vorgenommen Gpl Lizenzbedingungen, aber die Laufzeitbibliotheken waren nicht, was den Open -Source -Beitrag für die breite Öffentlichkeit unbrauchbar machte. Dies führte dazu, dass andere Parteien solche Laufzeitbibliotheken unter Open Source -Lizenz entwickelten. Später trug Steve Naroff auch einen wichtigen Beitrag zur Arbeit bei Apple, um das Ziel-C-Frontende aufzubauen Klang.

Das GNU Das Projekt begann mit der Arbeit an der kostenlosen Software -Implementierung von Kakao, genannt Gn .p, basierend auf OpenStep Standard.^[10] Dennis Glatting schrieb das erste GNU-Ziel-C Laufzeit 1992. Die seit 1993 verwendete GNU-Laufzeit für Objektive-C Dänemark. Thorup arbeitete auch von 1993 bis 1996.^[11]

Apfelentwicklung und Swift

Nach dem nächsten Erwerb im Jahr 1996, Apple Computer verwendet OpenStep in seinem damals neuen Betriebssystem, Mac OS X. Dies beinhaltete Objective-C, das Ziel-C-basierte Entwickler-Tool von Next. Projektbauerund sein Schnittstellen -Design -Tool, Schnittstellenbauer. Beide wurden später zu einer Anwendung zusammengeführt, Xcode. Der größte Teil von Apples aktuell Kakaoapi basiert auf OpenStep-Schnittstellenobjekten und ist die wichtigste Ziel-C-Umgebung, die für die aktive Entwicklung verwendet wird.

Bei WWDC 2014 stellte Apple eine neue Sprache vor, Schnell, was als "objektives C ohne C" charakterisiert wurde.

Syntax

Objective-C ist eine dünne Schicht auf C und ist ein "strenger" Superset"von C, was bedeutet, dass es möglich ist, ein C-Programm mit einem Objektiv-C-Compiler zu kompilieren und C-Sprachcode in einer Objektiv-C-Klasse frei aufzunehmen.^{[12][13][14][15][16][17]}

Objective-C leitet seine Objektsyntax ab Smalltalk. Die gesamte Syntax für nicht-objektorientierte Operationen (einschließlich primitiver Variablen, Vorverarbeitung, Ausdrücke, Funktionserklärung und Funktionsaufrufe) sind mit denen von C identisch, während die Syntax für objektorientierte Merkmale eine Implementierung von Smalltalk- ist. Style Messaging.

Mitteilungen

Das Ziel-C-Modell der objektorientierten Programmierung basiert auf Nachrichtenübergang zu Objektinstanzen. In Objective-C ist man nicht Rufen Sie eine Methode auf; eines sendet eine Nachricht. Dies ist anders als die Simula-Stil -Programmiermodell von im Stil verwendet von C ++. Der Unterschied zwischen diesen beiden Konzepten besteht darin, wie der von der Methode oder des Nachrichtennamen verwiesene Code ausgeführt wird. In einer Sprache im Simula-Stil ist der Methodenname in den meisten Fällen gebunden zu einem Codeabschnitt in der Zielklasse durch den Compiler. Im Smalltalk und Objective-C, das Ziel einer Nachricht wird zur Laufzeit behoben, wobei das empfangende Objekt selbst die Nachricht interpretiert. Eine Methode wird durch a identifiziert Wähler oder Sel - Eine eindeutige Kennung für jeden Nachrichtennamen, oft nur ein Nul-Erdierte Zeichenfolge Darstellung seines Namens - und auf eine C -Methode gelöst Zeiger Implementierung: a Imp.^[18] Eine Folge davon ist, dass das Nachrichten-Passing-System keine Typprüfung hat. Das Objekt, auf das die Nachricht gerichtet ist - die Empfänger - Es wird nicht garantiert, dass sie auf eine Nachricht antwortet, und wenn dies nicht der Fall ist, wird eine Ausnahme hervorgerufen.^[19]

Senden der Nachricht Methode auf das von dem Zeiger gerichtete Objekt obj würde den folgenden Code in erfordern in C ++:

obj->Methode(Streit); 

In Objective-C ist dies wie folgt geschrieben:

[obj Methode:Streit]; 

Der "Methode" -Auf wird vom Compiler in die übersetzt objc_msgsend (id self, sel op, ...) Familie der Laufzeitfunktionen. Verschiedene Implementierungen behandeln moderne Ergänzungen wie super.^[20] In GNU -Familien wird diese Funktion benannt OBJC_MSG_SENDV, aber es wurde zugunsten eines modernen Suchsystems unter veraltet OBJC_MSG_LOOKUP.^[21]

Beide Programmstile haben ihre Stärken und Schwächen. Objekt orientierte Programmierung in der Simula (C ++) Stil erlaubt Mehrfacherbe und schnellere Ausführung durch Verwendung Kompilierungszeitbindung Wann immer möglich, aber es unterstützt es nicht Dynamische Bindung standardmäßig. Es erzwingt auch alle Methoden, um eine entsprechende Umsetzung zu haben, es sei denn, sie sind es abstrakt. Die in Objective-C verwendete Programmierung im SmallTalk-Stil ermöglicht es, dass Nachrichten nicht implementiert werden, wobei die Methode zur Laufzeit auf ihre Implementierung aufgelöst wird. Zum Beispiel kann eine Nachricht an eine Sammlung von Objekten gesendet werden, auf die nur einige von einigen erwartet werden, dass sie reagieren, ohne Angst, Laufzeitfehler zu erzeugen. Die Übergabe von Nachrichten erfordert auch nicht, dass ein Objekt zum Kompilierungszeit definiert wird. Eine Implementierung ist weiterhin erforderlich, damit die Methode im abgeleiteten Objekt aufgerufen wird. (Siehe Dynamisches Typing Abschnitt unten für weitere Vorteile der dynamischen (späten) Bindung.)

Schnittstellen und Implementierungen

Objective-C erfordert, dass die Schnittstelle und Implementierung einer Klasse in separat deklarierten Codeblöcken sind. Nach Konvention legen Entwickler die Schnittstelle in a Header-Datei und die Implementierung in einer Codedatei. Die Header -Dateien, die normalerweise Suffixed .H, ähneln C -Header -Dateien, während die implementierenden Dateien (Methoden), die normalerweise Suffixed .m, sehr ähnlich zu C -Codedateien sein kann.

Schnittstelle

Dies ist analog zu Klassenerklärungen, wie sie in anderen objektorientierten Sprachen wie C ++ oder Python verwendet werden.

Die Schnittstelle einer Klasse wird normalerweise in einer Header -Datei definiert. Eine gemeinsame Konvention besteht darin, die Header -Datei nach dem Namen der Klasse zu benennen, z. Ball.h würde die Schnittstelle für die Klasse enthalten Ball.

Eine Schnittstellenerklärung nimmt das Formular an:

@Schnittstelle Klassenname: Superklassename {   // Instanzvariablen } + ClassMethod1; + (return_type)ClassMethod2; + (return_type)ClassMethod3:(param1_type)param1_varname; - (return_type)Instancemethod1With1Parameter:(param1_type)param1_varname; - (return_type)Instancemethod2With2Parameters:(param1_type)param1_varname   param2_callname:(param2_type)param2_varname; @Ende 

Im obigen plus Zeichen bezeichnen Klassenmethoden, oder Methoden, die die Klasse selbst (nicht in einer Instanz) aufgerufen werden können, und abzüglich Zeichen bezeichnen Instanzmethoden, die nur zu einer bestimmten Instanz der Klasse aufgerufen werden können. Klassenmethoden haben auch keinen Zugriff auf Instanzvariablen.

Der obige Code entspricht ungefähr der folgenden C ++ Schnittstelle:

Klasse Klassenname : Öffentlichkeit Superklassename { geschützt:   // Instanzvariablen Öffentlichkeit:   // Klasse (statische) Funktionen   statisch Leere *ClassMethod1();   statisch return_type ClassMethod2();   statisch return_type ClassMethod3(param1_type param1_varname);   // Instanz (Mitglied) Funktionen   return_type Instancemethod1With1Parameter(param1_type param1_varname);   return_type   Instancemethod2With2Parameters(param1_type param1_varname,   param2_type param2_varname = Ursprünglich); }; 

Beachten Sie, dass Instancemethod2With2Parameters: param2_callname: Demonstriert die Verschachtung von Selektorsegmenten mit Argumentausdrücken, für die es kein direktes Äquivalent in C/C ++ gibt.

Rückgabetypen können jeder Standard sein C Geben Sie einen Zeiger auf ein generisches Objektiv-C-Objekt ein, einen Zeiger auf einen bestimmten Objekttyp wie NSArray *, NSIMage *oder NSString *oder einen Zeiger auf die Klasse, zu der die Methode gehört (Instancetyp). Der Standard-Rückgabetyp ist der generische Objektiv-C-Typ Ich würde.

Methodenargumente beginnen mit einem Namen, das das Argument kennzeichnet, das Teil des Methodennamens ist, gefolgt von einem Dickdarm, gefolgt von dem erwarteten Argumenttyp in Klammern und dem Argumentnamen. Das Etikett kann weggelassen werden.

- (Leere)setRangEnestart:(int)Anfang Ende:(int)Ende; - (Leere)ImportDocumentWitHNAME:(Nsstring *)Name   With SpecifiedPreferences:(Vorlieben *)Prefs   Vorpage:(int)Insertpage; 

Eine Ableitung der Schnittstellendefinition ist die Kategorie, was es ermöglicht, Methoden zu vorhandenen Klassen hinzuzufügen.^[22]

Implementierung

Die Schnittstelle deklariert nur die Klassenschnittstelle und nicht die Methoden selbst: Der tatsächliche Code ist in der Implementierungsdatei geschrieben. Implementierungsdateien (Methoden) haben normalerweise die Dateierweiterung .m, was ursprünglich "Nachrichten" bedeutete.^[23]

@Implementierung Klassenname + (return_type)Klassenmethode {   // Implementierung } - (return_type)Instancemethod {   // Implementierung } @Ende 

Methoden werden mit ihren Schnittstellendeklarationen geschrieben. Vergleich von Objektiv-C und C:

- (int)Methode:(int)i {   Rückkehr [selbst Quadratwurzel:i]; } 

int Funktion(int i) {   Rückkehr Quadratwurzel(i); } 

Die Syntax ermöglicht Pseudo-Benennung von Argumenten.

- (Leere)ChangeColortored:(schweben)rot grün:(schweben)grün blau:(schweben)blau {   //... Implementierung ... } // SO so genannt: [Meine farbe ChangeColortored:5.0 grün:2.0 blau:6.0]; 

Interne Darstellungen einer Methode variieren zwischen verschiedenen Implementierungen von Objective-C. Wenn Mykolor der Klasse ist Farbe, Instanzmethode -ChangeColorted: Grün: Blau: könnte intern beschriftet sein _i_color_changeColorted_green_blue. Das i bezieht sich auf eine Instanzmethode mit den angehängten Klasse und den angehängten Methodennamen und Colons in Unterstriche. Da die Reihenfolge der Parameter Teil des Methodennamens ist, kann sie nicht nach dem Codierungsstil oder -ausdruck geändert werden, wie bei den wahren benannten Parametern.

Interne Namen der Funktion werden jedoch selten direkt verwendet. Im Allgemeinen werden Nachrichten in Funktionsaufrufe konvertiert, die in der Objective-C-Laufzeitbibliothek definiert sind. Es ist nicht unbedingt zur Verknüpfungszeit bekannt, welche Methode aufgerufen wird, da die Klasse des Empfängers (das Objekt, das die Nachricht gesendet wird) bis zur Laufzeit nicht bekannt sein muss.

Instanziierung

Sobald eine objektive C-Klasse geschrieben ist, kann sie instanziiert werden. Dies geschieht durch die Zuordnung einer nicht initialisierten Instanz der Klasse (ein Objekt) und dann durch Initialisierung. Ein Objekt ist nicht voll funktionsfähig, bis beide Schritte abgeschlossen sind. Diese Schritte sollten mit einer Codezeile durchgeführt werden, damit es nie ein zugewiesenes Objekt gibt, das keine Initialisierung unterzogen wurde (und weil es unklug ist, das Zwischenergebnis seitdem zu behalten -drin kann ein anderes Objekt zurückgeben als das, auf dem es aufgerufen wird).

Instanziierung mit dem Standard-No-Parameter-Initialisierer:

MyObject *Foo = [[MyObject Alloc] drin]; 

Instanziierung mit einem benutzerdefinierten Initialisierer:

MyObject *Foo = [[MyObject Alloc] initWithString:Mystring]; 

In dem Fall, in dem keine benutzerdefinierte Initialisierung durchgeführt wird, kann die "neue" Methode häufig anstelle der Alloc-Init-Nachrichten verwendet werden:

MyObject *Foo = [MyObject Neu]; 

Einige Klassen implementieren auch Klassenmethoden -Initialisierer. Wie +neu, sie kombinieren +alloc und -drin, aber nicht wie +neu, sie geben eine autoreleadierte Instanz zurück. Einige Initialisierer der Klassenmethode nehmen Parameter an:

MyObject *Foo = [MyObject Objekt]; MyObject *Bar = [MyObject objektwithstring:@"Wikipedia :)"]; 

Das Alloc Die Nachricht bereitstellt genügend Speicher, um alle Instanzvariablen für ein Objekt zu halten, setzt alle Instanzvariablen auf Nullwerte und verwandelt den Speicher in eine Instanz der Klasse. Zu keinem Zeitpunkt während der Initialisierung ist das Speicher eine Instanz der Superklasse.

Das drin Nachricht führt die Einrichtung der Instanz bei der Erstellung durch. Das drin Die Methode wird oft wie folgt geschrieben:

- (Ich würde)drin {   selbst = [super drin];   wenn (selbst) {   // Hier die Initialisierung des Objekts durchführen   }   Rückkehr selbst; } 

Beachten Sie im obigen Beispiel die Ich würde Rückgabetyp. Dieser Typ steht für "Zeiger auf ein Objekt" in Objective-C (siehe die Dynamisches Typing Sektion).

Das Initialisierermuster wird verwendet, um sicherzustellen, dass das Objekt vor der Init -Methode seine Initialisierung ordnungsgemäß initialisiert wird. Es führt die folgenden Aktionen aus:

1. self = [super init]

   Sendet die Superklasse -Instanz an drin Nachricht und weist das Ergebnis zu selbst (Zeiger auf das aktuelle Objekt).

2. if (selbst)

   Überprüft, ob der zurückgegebene Objektzeiger vor der Durchführung einer Initialisierung gültig ist.

3. Rückkehr selbst

   Gibt den Wert des Selbst an den Anrufer zurück.

Ein Nicht-Valid-Objektzeiger hat den Wert Null; Bedingte Aussagen wie "Wenn" nil wie ein Nullzeiger behandeln, wird der Initialisierungscode nicht ausgeführt, wenn [Super init] NIL zurückgegeben hat. Wenn in der Initialisierung ein Fehler vorliegt, sollte die Init -Methode eine erforderliche Reinigung durchführen, einschließlich des Sendens einer "Release" -Meldung an sich selbst und zurücksend Null um anzuzeigen, dass die Initialisierung fehlgeschlagen ist. Alle Überprüfungen nach solchen Fehlern dürfen erst nach dem Aufrufen der Superklasseninitialisierung durchgeführt werden, um sicherzustellen, dass die Zerstörung des Objekts korrekt durchgeführt wird.

Wenn eine Klasse mehr als eine Initialisierungsmethode hat, muss nur einer von ihnen (der "benannte Initialisierer") diesem Muster folgen. Andere sollten den benannten Initialisierer anstelle des Superclass -Initialisierers anrufen.

Protokolle

In anderen Programmiersprachen werden diese als "Schnittstellen" bezeichnet.

Objektiv-C wurde bei erweitert Nächste das Konzept von vorstellen Mehrfacherbe der Spezifikation, aber nicht der Umsetzung durch die Einführung von Protokolle. Dies ist ein Muster, das entweder als abstrakte multiple ererbte Basisklasse in erreichbar ist C ++oder als "Schnittstelle" (wie in Java und C#). Objective-C verwendet Ad-hoc-Protokolle, die genannt werden Informelle Protokolle und Compiler-durchlässige Protokolle genannt Formale Protokolle.

Ein informelles Protokoll ist eine Liste von Methoden, die eine Klasse für die Implementierung entscheiden kann. Es ist in der Dokumentation angegeben, da es in der Sprache nicht vorhanden ist. Informelle Protokolle werden als implementiert Kategorie (Siehe unten) zu NSObject und fügen Sie häufig optionale Methoden ein, die, wenn sie implementiert werden, das Verhalten einer Klasse ändern können. Zum Beispiel könnte eine Textfeldklasse eine haben delegieren Dies implementiert ein informelles Protokoll mit einer optionalen Methode zur automatischen Vervollständigung des benutzerfreundlichen Textes. Das Textfeld stellt fest, ob der Delegate diese Methode impliziert (über Betrachtung) Und wenn ja, ruft die Methode des Delegaten auf, um die automatische Funktionsfunktion zu unterstützen.

Ein formales Protokoll ähnelt einem Schnittstelle in Java, C#und ADA 2005. Es handelt sich um eine Liste von Methoden, die sich jede Klasse für die Implementierung deklarieren kann. Versionen von Objective-C vor 2.0 erforderten, dass eine Klasse alle Methoden in einem Protokoll implementieren muss, das sich selbst als Einführung deklariert. Der Compiler wird einen Fehler abgibt, wenn die Klasse nicht jede Methode aus ihren deklarierten Protokollen implementiert. Objective-C 2.0 fügte Unterstützung für die Markierung bestimmter Methoden in einem Protokoll optional hinzu, und der Compiler wird die Implementierung optionaler Methoden nicht durchsetzen.

Eine Klasse muss erklärt werden, um dieses Protokoll zu implementieren, das sich daran anpassen soll. Dies ist zur Laufzeit nachweisbar. Formale Protokolle können keine Implementierungen bereitstellen. Sie versichern einfach Anrufer, dass Klassen, die dem Protokoll entsprechen, Implementierungen bereitstellen werden. In der nächsten/Apple -Bibliothek werden Protokolle häufig vom verteilten Objektsystem verwendet, um die Fähigkeiten eines auf einem Remote -System ausgeführten Objekts darzustellen.

Die Syntax

@Protokoll NSLocking - (Leere)sperren; - (Leere)Freischalten; @Ende 

bezeichnet, dass es die abstrakte Idee des Sperrens gibt. Indem Sie in der Klassendefinition feststellen, dass das Protokoll implementiert wird,

@Schnittstelle Nslock: NSOBJECT <NSLocking> // ... @Ende 

Instanzen von NSLOCK behaupten, dass sie eine Implementierung für die beiden Instanzmethoden liefern.

Dynamisches Typing

Objective-C wie SmallTalk kann verwenden Dynamisches Typing: Es kann einem Objekt eine Nachricht gesendet werden, die in seiner Schnittstelle nicht angegeben ist. Dies kann eine erhöhte Flexibilität ermöglichen, da ein Objekt eine Nachricht "erfassen" und die Nachricht an ein anderes Objekt senden kann, das auf die Nachricht angemessen reagieren kann, oder die Nachricht ebenfalls an ein anderes Objekt senden kann. Dieses Verhalten ist bekannt als Nachrichtenweiterung oder Delegation (siehe unten). Alternativ kann ein Fehlerhandler verwendet werden, falls die Nachricht nicht weitergeleitet werden kann. Wenn ein Objekt keine Nachricht weiterleitet, darauf reagiert oder einen Fehler behandelt, generiert das System eine Laufzeitausnahme.^[24] Wenn Nachrichten an gesendet werden Null (Der Null -Objektzeiger), sie werden je nach Compiler -Optionen stillschweigend ignoriert oder eine generische Ausnahme anziehen.

Statische Typisierungsinformationen können auch optional zu Variablen hinzugefügt werden. Diese Informationen werden dann zur Kompilierungszeit überprüft. In den folgenden vier Aussagen werden zunehmend spezifische Typinformationen bereitgestellt. Die Aussagen sind zur Laufzeit gleichwertig, aber die zusätzlichen Informationen ermöglichen es dem Compiler, den Programmierer zu warnen, wenn das bestandene Argument nicht mit dem angegebenen Typ übereinstimmt.

- (Leere)setMyValue:(Ich würde)Foo; 

In der obigen Aussage, Foo kann von jeder Klasse sein.

- (Leere)setMyValue:(Ich würde<NSCopying>)Foo; 

In der obigen Aussage, Foo kann eine Instanz einer Klasse sein, die sich dem entspricht NSCopying Protokoll.

- (Leere)setMyValue:(Nsnumber *)Foo; 

In der obigen Aussage, Foo Muss eine Instanz der sein Nsnumber Klasse.

- (Leere)setMyValue:(Nsnumber<NSCopying> *)Foo; 

In der obigen Aussage, Foo Muss eine Instanz der sein Nsnumber Klasse, und es muss dem entsprechen NSCopying Protokoll.

In Objective-C werden alle Objekte als Zeiger dargestellt, und die statische Initialisierung ist nicht zulässig. Das einfachste Objekt ist der Typ, der Ich würde (OBJC_OBJ *) zeigt auf, was nur eine hat ist ein Zeiger beschreibt seine Klasse. Andere Typen aus C wie Werte und Strukturen sind unverändert, da sie nicht Teil des Objektsystems sind. Diese Entscheidung unterscheidet sich vom C ++ - Objektmodell, bei dem Strukturen und Klassen vereint sind.

Weiterleitung

Objective-C ermöglicht das Senden einer Nachricht an ein Objekt, das möglicherweise nicht antwortet. Anstatt die Nachricht zu antworten oder einfach fallen zu lassen, kann ein Objekt die Nachricht an ein Objekt weiterleiten, das antworten kann. Die Weiterleitung kann verwendet werden, um die Implementierung bestimmter zu vereinfachen Designmuster, so wie die Beobachtermuster oder der Proxymuster.

Die Ziel-C-Laufzeit gibt ein Methodenpaar an Objekt

• Weiterleitungsmethoden:

  - (retval_t)nach vorne:(Sel)Sel Args:(arglist_t)Args; // mit GCC - (Ich würde)nach vorne:(Sel)Sel Args:(marg_list)Args; // mit Next/Apple Systems 

• Aktionsmethoden:

  - (retval_t)Performv:(Sel)Sel Args:(arglist_t)Args; // mit GCC - (Ich würde)Performv:(Sel)Sel Args:(marg_list)Args; // mit Next/Apple Systems 

Ein Objekt, das die Weiterleitung implementieren möchte, muss nur die Weiterleitungsmethode mit einer neuen Methode überschreiben, um das Weiterleitungsverhalten zu definieren. Die Aktionsmethode Performv :: muss nicht überschrieben werden, da diese Methode lediglich eine Aktion basierend auf dem Selektor und den Argumenten ausführt. Beachten Sie die SEL Typ, das ist die Art von Nachrichten in Objective-C.

Hinweis: In OpenStep, Kakao und Gn. Die häufig verwendeten Frameworks von Objective-C verwendet man die nicht Objekt Klasse. Das - (void) ForwardInvocation: (Nsinvocation *) AnInvocation Methode der NSOBJECT Die Klasse wird zur Weiterleitung verwendet.

Beispiel

Hier ist ein Beispiel für ein Programm, das die Grundlagen der Weiterleitung demonstriert.

Forwarder.h

#import <objc/object.h> @Schnittstelle Spediteur: Objekt {   Ich würde Empfänger; // das Objekt, an das wir die Nachricht weiterleiten möchten. } // Accessor -Methoden. - (Ich würde)Empfänger; - (Ich würde)setRecipient:(Ich würde)_Empfänger; @Ende 

Forwarder.m

#import "Forwarder.h" @Implementierung Spediteur - (retval_t)nach vorne:(Sel)Sel Args:(arglist_t)Args {   /*   * Überprüfen Sie, ob der Empfänger tatsächlich auf die Nachricht antwortet.   * Dies kann beispielsweise bei einem Empfänger wünschenswert sein oder nicht   * wiederum antwortet nicht auf die Nachricht, sondern kann weiterleiten   * selbst.   */   wenn [Empfänger ResponseToselector:Sel])) {   Rückkehr [Empfänger Performv:Sel Args:Args];   } anders {   Rückkehr [selbst Error:"Der Empfänger antwortet nicht"];   } } - (Ich würde)setRecipient:(Ich würde)_Empfänger {   [Empfänger Autorelease];   Empfänger = [_Empfänger zuückbehalten];   Rückkehr selbst; } - (Ich würde)Empfänger {   Rückkehr Empfänger; } @Ende 

Empfänger.h

#import <objc/object.h> // ein einfaches Empfängerobjekt. @Schnittstelle Empfänger: Objekt - (Ich würde)hallo; @Ende 

Empfänger.M

#import "Empfänger.h" @Implementierung Empfänger - (Ich würde)hallo {   printf("Empfänger sagt Hallo!\n");   Rückkehr selbst; } @Ende 

main.m

#import "Forwarder.h" #import "Empfänger.h" int hauptsächlich(Leere) {   Spediteur *Spediteur = [Spediteur Neu];   Empfänger *Empfänger = [Empfänger Neu];   [Spediteur setRecipient:Empfänger]; // Setzen Sie den Empfänger.   /*   * Beobachten Sie Spediteur antwortet nicht auf eine Hallo -Nachricht! Es wird   * weitergeleitet werden. Alle unerkannten Methoden werden an weitergeleitet   * Der Empfänger   * (Wenn der Empfänger auf sie antwortet, wie im Spediteur geschrieben)   */   [Spediteur hallo];   [Empfänger Veröffentlichung];   [Spediteur Veröffentlichung];   Rückkehr 0; } 

Anmerkungen

Bei kompilierter Verwendung GCC, Der Compiler berichtet:

$ gcc -x objektiv -c -wno -Import Forwarder.m Empfänger.m main.m -Lobjc main $

Der Compiler meldet den zuvor gemachten Punkt, das Spediteur antwortet nicht auf Hallo -Nachrichten. Unter diesen Umständen ist es sicher, die Warnung seit dem Weiterleiten zu ignorieren. Das Ausführen des Programms erzeugt diese Ausgabe:

$ ./a.out Empfänger sagt Hallo!

Kategorien

Während der Gestaltung von Objektiv-C war eine der Hauptprobleme die Wartbarkeit großer Codebasen. Erfahrung aus dem Strukturierte Programmierung World hatte gezeigt, dass eine der Hauptmethoden zur Verbesserung des Code darin bestand, ihn in kleinere Stücke zu zerlegen. Objektiv-C geliehen und erweiterte das Konzept von Kategorien aus SmallTalk -Implementierungen, um diesen Prozess zu unterstützen.^[25]

Darüber hinaus werden die Methoden innerhalb einer Kategorie zu einer Klasse bei hinzugefügt Laufzeit. Daher ermöglichen Kategorien dem Programmierer, Methoden zu einer vorhandenen Klasse hinzuzufügen - ein offene Klasse - Ohne die Notwendigkeit, diese Klasse neu zu kompilieren oder sogar Zugriff auf seinen Quellcode zu haben. Zum Beispiel, wenn ein System keine enthält Rechtschreibprüfung In seiner String -Implementierung könnte es hinzugefügt werden, ohne den String -Quellcode zu ändern.

Methoden innerhalb der Kategorien werden von den Methoden in einer Klasse nicht zu unterscheiden, wenn das Programm ausgeführt wird. Eine Kategorie hat vollen Zugriff auf alle Instanzvariablen innerhalb der Klasse, einschließlich privater Variablen.

Wenn eine Kategorie eine Methode mit derselben deklariert Methodensignatur Als vorhandene Methode in einer Klasse wird die Methode der Kategorie angewendet. Daher können Kategorien nicht nur Methoden zu einer Klasse hinzufügen, sondern auch vorhandene Methoden ersetzen. Diese Funktion kann verwendet werden, um Fehler in anderen Klassen zu beheben, indem sie ihre Methoden neu schreiben, oder um das Verhalten einer Klasse innerhalb eines Programms global zu ändern. Wenn zwei Kategorien Methoden mit demselben Namen, aber unterschiedlichen Methodensignaturen haben, ist nicht definiert, welche Methode der Kategorie angewendet wird.

Andere Sprachen haben versucht, diese Funktion auf verschiedene Weise hinzuzufügen. Tom ging das Ziel-C-System noch weiter und erlaubte auch die Zugabe von Variablen. Andere Sprachen haben verwendet Prototypbasiert Lösungen stattdessen das bemerkenswerteste Wesen Selbst.

Die Sprachen von c# und visual basic.net implementieren oberflächlich ähnliche Funktionen in Form von Verlängerungsmethoden, aber diese fehlt Zugang zu den privaten Variablen der Klasse.^[26] Rubin und mehrere andere dynamische Programmiersprachen beziehen sich auf die Technik als "Affenpatching".

Logtalk Implementiert ein Konzept von Kategorien (als erstklassige Entitäten), das die Funktionalität der objektiven C-Kategorien (Logtalk-Kategorien kann auch als feinkörnige Kompositionseinheiten verwendet werden importiert nach einer beliebigen Anzahl von Klassen und Prototypen).

Beispiel Verwendung von Kategorien

Dieses Beispiel baut eine auf Ganze Zahl Klasse, indem zuerst eine grundlegende Klasse mit nur definiert wird Accessor -Methoden implementiert und hinzufügen zwei Kategorien, Arithmetik und Anzeige, die die Grundklasse erweitern. Während Kategorien auf die privaten Datenmitglieder der Basisklasse zugreifen können, ist es häufig eine gute Praxis, über die Accessor -Methoden auf diese privaten Datenmitglieder zugreifen zu können, wodurch die Kategorien unabhängiger von der Basisklasse gehalten werden. Die Implementierung solcher Accessoren ist eine typische Verwendung von Kategorien. Eine andere besteht darin, Kategorien zu verwenden, um Methoden zur Basisklasse hinzuzufügen. Es wird jedoch nicht als gute Praxis angesehen, Kategorien für die Überschreibung von Unterklassen zu verwenden, auch bekannt als Affenpatching. Informelle Protokolle werden als Kategorie auf der Basis implementiert NSOBJECT Klasse. Nach Konvention nehmen Dateien mit Kategorien, die die Basisklassen erweitern BaseClass+ExtensionClass.h.

Integer.h

#import <objc/object.h> @Schnittstelle Ganze Zahl: Objekt {   int ganze Zahl; } - (int)ganze Zahl; - (Ich würde)ganze Zahl:(int)_ganze Zahl; @Ende 

Integer.m

#import "Integer.h" @Implementierung Ganze Zahl - (int) ganze Zahl {   Rückkehr ganze Zahl; } - (Ich würde) ganze Zahl: (int) _ganze Zahl {   ganze Zahl = _ganze Zahl;   Rückkehr selbst; } @Ende 

Ganzzahl+Arithmetik.h

#import "Integer.h" @Schnittstelle Ganze Zahl (Arithmetik) - (Ich würde) hinzufügen: (Ganze Zahl *) Summand; - (Ich würde) Sub: (Ganze Zahl *) Subtrahend; @Ende 

Ganzzahl+Arithmetik.m

#import "Integer+arithmetic.h" @Implementierung Ganze Zahl (Arithmetik) - (Ich würde) hinzufügen: (Ganze Zahl *) Summand {   Rückkehr [selbst ganze Zahl: [selbst ganze Zahl] + [Summand ganze Zahl]]; } - (Ich würde) Sub: (Ganze Zahl *) Subtrahend {   Rückkehr [selbst ganze Zahl: [selbst ganze Zahl] - [Subtrahend ganze Zahl]]; } @Ende 

Ganzzahl+Display.h

#import "Integer.h" @Schnittstelle Ganze Zahl (Anzeige) - (Ich würde) Showstars; - (Ich würde) Showt; @Ende 

Ganzzahl+Display.m

# Import "Integer+display.h" @Implementierung Ganze Zahl (Anzeige) - (Ich würde) Showstars {   int i, x = [selbst ganze Zahl];   zum (i = 0; i < x; i++) {   printf("*");   }   printf("\n");   Rückkehr selbst; } - (Ich würde) Showt {   printf("%d\n", [selbst ganze Zahl]);   Rückkehr selbst; } @Ende 

main.m

#import "Integer.h" #import "Integer+arithmetic.h" #import "Integer+display.h" int hauptsächlich(Leere) {   Ganze Zahl *Num1 = [Ganze Zahl Neu], *Num2 = [Ganze Zahl Neu];   int x;   printf("Geben Sie eine Ganzzahl ein:");   Scanf("%d", &x);   [Num1 ganze Zahl:x];   [Num1 Showstars];   printf("Geben Sie eine Ganzzahl ein:");   Scanf("%d", &x);   [Num2 ganze Zahl:x];   [Num2 Showstars];   [Num1 hinzufügen:Num2];   [Num1 Showt];   Rückkehr 0; } 

Anmerkungen

Die Zusammenstellung wird beispielsweise von:

gcc -x objective -c main.m Integer.m Integer+arithmetic.m Integer+display.m -Lobjc

Man kann experimentieren, indem man das auslassen #import "Integer+arithmetic.h" und [Num1 Add: Num2] Zeilen und Auslass Ganzzahl+Arithmetik.m in Zusammenstellung. Das Programm wird immer noch ausgeführt. Dies bedeutet, dass es möglich ist mischen und Anpassen Bei Bedarf Kategorien hinzugefügt; Wenn eine Kategorie keine Fähigkeit benötigt, kann sie einfach nicht kompiliert werden.

Posieren

Objective-C ermöglicht es einer Klasse, eine andere Klasse innerhalb eines Programms vollständig zu ersetzen. Die Ersetzungsklasse soll "als Zielklasse posieren".

Die Klassenposing wurde mit veraltet erklärt mit Mac OS X v10.5und ist in der 64-Bit-Laufzeit nicht verfügbar. Eine ähnliche Funktionalität kann durch Verwendung von Methoden in Kategorien erreicht werden, die die Implementierung einer Methode mit einer anderen übertragen, die dieselbe Signatur aufweisen.

Für die immer noch unterstützenden Versionen, die Posen unterstützen, werden alle Nachrichten, die an die Zielklasse gesendet werden, von der Posing -Klasse empfangen. Es gibt mehrere Einschränkungen:

• Eine Klasse darf nur als eine der direkten oder indirekten Superklassen darstellen.
• Die Posing -Klasse darf keine neuen Instanzvariablen definieren, die in der Zielklasse fehlen (obwohl sie Methoden definieren oder überschreiben kann).
• Die Zielklasse hat möglicherweise keine Nachrichten vor dem Posen erhalten.

Das Posieren ähnlich mit Kategorien ermöglicht die globale Erweiterung bestehender Klassen. Das Posen ermöglicht zwei Features, die in den Kategorien fehlen:

• Eine Posing -Klasse kann über Super Overdiden -Methoden aufrufen, wodurch die Implementierung der Zielklasse einbezogen wird.
• Eine Posing -Klasse kann in Kategorien definierte Methoden überschreiben.

Zum Beispiel,

@Schnittstelle CustomNSapplication: NSapplication @Ende @Implementierung CustomNSapplication - (Leere) setMainmenu: (Nsmenu*) Speisekarte {   // etwas mit dem Menü mach } @Ende class_poseas [CustomNSapplication Klasse], [NSapplication Klasse]); 

Dies fängt jede Aufruf von SetMainmenu in die NSapplication ab.

#importieren

In der C -Sprache die #enthalten Die Vorkompilierrichtlinie führt immer dazu, dass der Inhalt einer Datei an diesem Punkt in die Quelle eingefügt wird. Objektiv-c hat das #importieren Die äquivalente Richtlinie mit Ausnahme, dass jede Datei nur einmal pro Kompilierungseinheit enthalten ist, wobei die Notwendigkeit der Notwendigkeit vermieden wird Wachen einbeziehen.

Linux GCC -Zusammenstellung

// Datei: Hallo.m #import <foundation/foundation.h> int hauptsächlich (int argc, Const verkohlen * argv[]) {   / * Mein erstes Programm in Objective-C *//   Nslog(@"Hallo Welt! \n");   Rückkehr 0; } 

# Befehlszeile für GCC und Mingw Compiler kompilieren: $ gcc \  $ (gn .p-config --objc-flags) \     -O Hallo \     Hallo.m \     -L/gn .p/System/Bibliothek/Bibliotheken \     -Lobjc \     -lgnustep-base $ ./hello

Andere Eigenschaften

Die Funktionen von Objective-C ermöglichen häufig flexible und oft einfache Lösungen für Programmierprobleme.

• Methoden an andere Objekte delegieren und Remote -Aufruf kann einfach mit Kategorien und Nachrichtenweiterungen implementiert werden.
• Reduzieren des ist ein Zeiger ermöglicht es, sich zur Laufzeit zu ändern. Typisch verwendet für Debuggen Wo befreite Objekte in Zombie -Objekte regelt werden, deren einziger Zweck darin besteht, einen Fehler zu melden, wenn jemand sie anruft. Swizzling wurde auch in verwendet Enterprise -Objekt -Framework Datenbankfehler erstellen. Swizzling wird heute im Foundation Framework von Apple verwendet, um die Beobachtung der Schlüsselwerte zu implementieren.

Sprachvarianten

Ziel-C ++

Objective-C ++ ist eine Sprachvariante, die vom Front-End an die angenommen wird GNU Compiler -Sammlung und Klang, die Quelldateien kompilieren können, die eine Kombination aus C ++ und Objective-C-Syntax verwenden. Objective-C ++ fügt C ++ zu den Erweiterungen hinzu, die Objective-C zu C hinzufügt. Da nichts getan wird, um die Semantik hinter den verschiedenen Sprachmerkmalen zu vereinen, gelten bestimmte Einschränkungen:

• Eine C ++-Klasse kann nicht von einer objektiven C-Klasse abgeleitet und umgekehrt.
• C ++-Namespaces kann nicht in einer Objektiv-C-Deklaration deklariert werden.
• Objektiv-C-Deklarationen können nur in globalem Umfang erscheinen, nicht in einem C ++-Namespace
• Objective-C-Klassen können keine Instanzvariablen von C ++-Klassen haben, denen a fehlen Standardkonstruktor oder das hat einen oder mehrere Virtuelle Methoden, aber Zeiger auf C ++ -Objekte können als Instanzvariablen ohne Einschränkung verwendet werden (zuweisen sie mit neuer in der -init -Methode).
• C ++ "By Value" -Semantik kann nicht auf Objective-C-Objekte angewendet werden, die nur über Zeiger zugänglich sind.
• Eine Objektiv-C-Deklaration kann nicht innerhalb einer C ++-Vorlagenerklärung sein und umgekehrt. Objektiv-C-Typen (z. B.,,, Classname *) kann als C ++ - Vorlagenparameter verwendet werden.
• Die Ausnahmebehandlung von Objektiv-C und C ++ ist unterschiedlich; Die Handler eines jeden können keine Ausnahmen des anderen Typs behandeln. Infolgedessen werden Objektzerstörer nicht ausgeführt. Dies wird in den jüngsten "Objective-C 2.0" -Rungen gemindert, da objektive C-Ausnahmen entweder durch C ++-Ausnahmen vollständig (Apple-Laufzeit) ersetzt werden, oder teilweise, wenn die Objektive-C ++ -Bibliothek verknüpft ist (GNUstep libobjc2).^[27]
• Objektiv-C-Blöcke und C ++ 11 Lambdas sind unterschiedliche Wesenheiten. Ein Block wird jedoch auf macOS transparent erzeugt, wenn ein Block erwartet wird.^[28]

Ziel-C 2.0

Bei der 2006 Weltweite Entwicklerkonferenz, Apple kündigte die Veröffentlichung von "Objective-C 2.0" an, eine Überarbeitung der Objektiv-C-Sprache, die "moderne Müllsammlung, Syntaxverbesserungen, umfasst, umfasst,^[29] Laufzeitleistung Verbesserungen,^[30] und 64-Bit-Unterstützung ". Mac OS X v10.5, veröffentlicht im Oktober 2007, enthielt einen Objektiv-C 2.0-Compiler. GCC 4.6 Unterstützt viele neue Objektiv-C-Merkmale, wie z. B. deklarierte und synthetisierte Eigenschaften, DOT-Syntax, schnelle Aufzählung, optionale Protokollmethoden, Methoden-/Protokoll-/Klassenattribute, Klassenerweiterungen und eine neue GNU-Ziel-C-Laufzeit-API.^[31]

Das Namensziel-C. 2.0 stellt einen Unterbrechung im Versioning-System der Sprache dar, da die letzte Ziel-C-Version für Next "OBJC4" war.^[32] Dieser Projektname wurde in der letzten Veröffentlichung des Legacy Objective-C-Laufzeit-Quellcodes in gehalten Mac OS X Leopard (10.5).^[33]

Müllsammlung

Objective-C 2.0 lieferte einen optionalen konservativen Generation generationsübergreifend Müllsammler. Beim Laufen rückwärtskompatibel Modus, die Laufzeit drehte sich Referenzzählung Operationen wie "Retain" und "Release" in No-Ops. Alle Objekte waren der Müllsammlung ausgesetzt, wenn die Müllsammlung aktiviert war. Regelmäßige C-Zeiger könnten mit "__strong" qualifiziert werden, um auch die zugrunde liegenden Schreibbärgs-Compiler-Abschnitte auszulösen und somit an der Müllsammlung teilzunehmen.^[34] Es wurde auch ein schwaches Subsystem mit Null-ing-Subsystem bereitgestellt, so dass Zeiger, die als "__Weak" gekennzeichnet sind, auf Null gesetzt werden, wenn das Objekt (oder einfacher GC-Speicher) gesammelt wird. Der Müllsammler existiert bei der iOS-Implementierung von Objective-C 2.0 nicht.^[35] Die Müllsammlung in Objective-C läuft mit einem Hintergrund-Thread mit niedriger Priorität und kann auf Benutzerereignisse stoppen, um die Benutzererfahrung reaktionsschnell zu halten.^[36]

Die Müllsammlung wurde in Mac OS X V10.8 zugunsten von veraltet Automatische Referenzzählung (BOGEN).^[37] Objektiv-c auf iOS 7 Laufen ARM64 verwendet 19 Bit aus einem 64-Bit-Wort, um die Referenzzahl als Form von zu speichern Markierte Zeiger.^[38][39]

Eigenschaften

Objective-C 2.0 führt eine neue Syntax ein, um Instanzvariablen zu deklarieren Eigenschaftenmit optionalen Attributen zur Konfiguration der Erzeugung von Accessor -Methoden. Eigenschaften sind in gewissem Sinne öffentliche Instanzvariablen; Das heißt, eine Instanzvariable als Eigenschaft bietet externe Klassen mit Zugriff (möglicherweise nur begrenzt, z. B. nur Lesen) dieser Eigenschaft. Eine Eigenschaft kann als "readonly" deklariert und mit Speichersemantik wie z. zuordnen, Kopieren oder zuückbehalten. Standardmäßig werden Eigenschaften berücksichtigt Atomic, was dazu führt, dass ein Schloss verhindert, dass mehrere Threads gleichzeitig darauf zugreifen. Eine Immobilie kann als deklariert werden als als nichtatomar, was dieses Schloss entfernt.

@Schnittstelle Person: NSOBJECT { @Öffentlichkeit   Nsstring *Name; @Privatgelände   int das Alter; } @Eigentum(Kopieren) Nsstring *Name; @Eigentum(schreibgeschützt) int das Alter; - (Ich würde)Initwithage:(int)das Alter; @Ende 

Eigenschaften werden durch die implementiert @synthesize Schlüsselwort, das gemäß der Eigenschaftserklärung Getter (und Setter, wenn nicht nur schreibgeschützte) Methoden generiert. Alternativ müssen die Getter- und Setter -Methoden explizit oder die ausdrücklich implementiert werden @dynamic Schlüsselwort kann verwendet werden, um anzuzeigen, dass Accessor -Methoden mit anderen Mitteln bereitgestellt werden. Bei kompilierter Verwendung von Clang 3.1 oder höher alle Eigenschaften, die nicht explizit mit erklärt werden @dynamic, markiert schreibgeschützt oder haben vollständige benutzergerätedelige Getter und Setter werden automatisch implizit @synthesize'd.

@Implementierung Person @synthesize Name; - (Ich würde)Initwithage:(int)Initage {   selbst = [super drin];   wenn (selbst) {   // Hinweis: Direktinstanzvariable Zuordnung, nicht Eigenschaftssistter   das Alter = Initage;   }   Rückkehr selbst; } - (int)das Alter {   Rückkehr das Alter; } @Ende 

Auf die Eigenschaften können mit der traditionellen Nachrichtenübergabe-Syntax, Punktnotation oder in der Schlüsselwertcodierung über den Namen "Valueforkey:"/"SetValue: Forkey:" -Methoden zugegriffen werden.

Person *eine Person = [[Person Alloc] Initwithage:53]; eine Person.Name = @"Steve"; // Hinweis: DOT -Notation, verwendet synthetisierten Setter,   // Äquivalent zu [Aperson setName: @"Steve"]; Nslog(@"Zugriff nach Nachricht (%@), Punktnotation (%@), Eigenschaftsname (%@) und"   "Direct Instance Variable Access (% @)",   [eine Person Name],   eine Person.Name, [eine Person ValueForKey:@"Name"], eine Person -> Name); 

Um die Punktnotation zu verwenden, um Eigenschaftszubehör innerhalb einer Instanzmethode aufzurufen, sollte das Schlüsselwort "Selbst" verwendet werden:

- (Leere)EINFAHREMYSELFWITHPROPERTIES:(Bool)Anwender {   Nslog(@"Hi, mein Name ist %@.", (Anwender ? selbst.Name : Name));   // Hinweis: Getter vs. Ivar Access } 

Die Eigenschaften eines Klasse oder Protokolls können dynamisch sein gezwungen.

int i; int PropertyCount = 0; OBJC_PROPERTY_T *PropertyList =   class_copyPropertyList[eine Person Klasse], &PropertyCount); zum (i = 0; i < PropertyCount; i++) {   OBJC_PROPERTY_T *diese Liegenschaft = PropertyList + i;   Const verkohlen *Name des Anwesens = Property_getName(*diese Liegenschaft);   Nslog(@"Person hat eine Immobilie: '%s'", Name des Anwesens); } 

Nicht-fragile Instanzvariablen

Objective-C 2.0 bietet nicht-fragile Instanzvariablen, bei denen die Laufzeit unterstützt wird (d. H. Beim Erstellen von Code für 64-Bit-MacOS und alle iOS). Unter der modernen Laufzeit wird eine zusätzliche Indirektionschicht zum Instanzvariablenzugriff hinzugefügt, sodass der dynamische Linker das Instanzlayout zur Laufzeit anpassen kann. Diese Funktion ermöglicht zwei wichtige Verbesserungen des Objektiv-C-Code:

• Es eliminiert die Fragile Binärschnittstellenproblem; Superklassen können Größen ändern, ohne die binäre Kompatibilität zu beeinträchtigen.
• Es ermöglicht Instanzvariablen, die die Unterstützung für Eigenschaften zur Laufzeit synthetisiert werden, ohne dass sie in der Schnittstelle der Klasse deklariert werden.

Schnelle Aufzählung

Anstatt ein Nsenumerator-Objekt oder Indizes zu verwenden, um durch eine Sammlung zu iterieren, bietet Objective-C 2.0 die schnelle Aufzählungssyntax. In Objective-C 2.0 sind die folgenden Schleifen funktional äquivalent, haben jedoch unterschiedliche Leistungsmerkmale.

// Verwenden von Nsenumerator Nsenumerator *Aufzähler = [die Menschen Objektivator]; Person *p; während ((p = [Aufzähler NextObject])) ! = Null) {   Nslog(@ " %@ ist %I Jahre alt.", [p Name], [p das Alter]); } 

// Verwenden von Indizes zum (int i = 0; i < [die Menschen zählen]; i++) {   Person *p = [die Menschen ObjectatIndex:i];   Nslog(@ " %@ ist %I Jahre alt.", [p Name], [p das Alter]); } 

// mit einer schnellen Aufzählung verwenden zum (Person *p in die Menschen) {   Nslog(@ " %@ ist %I Jahre alt.", [p Name], [p das Alter]); } 

Eine schnelle Aufzählung generiert effizientere Code als Standard -Aufzählung, da Methodenaufrufe zur Aufzählung von Objekten durch Zeigerarithmetik unter Verwendung des NSFastEnumeration -Protokolls ersetzt werden.^[40]

Klassenerweiterungen

Eine Klassenerweiterung hat dieselbe Syntax wie eine Kategorie -Deklaration ohne Kategorienname, und die darin enthaltenen Methoden und Eigenschaften werden direkt zur Hauptklasse hinzugefügt. Es wird hauptsächlich als Alternative zu einer Kategorie verwendet, um Methoden zu einer Klasse hinzuzufügen, ohne sie in den öffentlichen Headern zu bewerben, mit dem Vorteil, dass der Compiler für die Klassenverlängerung überprüft, ob alle privat deklarierten Methoden tatsächlich implementiert werden.^[41]

Implikationen für die Kakaoentwicklung

Alle für macOS entwickelten Ziel-C-Anwendungen, die die oben genannten Verbesserungen für Objective-C 2.0 nutzen, sind mit allen Betriebssystemen vor 10.5 (Leopard) nicht kompatibel. Da die schnelle Aufzählung nicht genau die gleichen Binärdateien wie Standard -Aufzählung generiert, wird eine Anwendung auf Mac OS X Version 10.4 oder früher abgestürzt.

Blöcke

Blöcke sind eine nicht standardmäßige Erweiterung für Objektiv-C (und C und C ++) Das verwendet eine spezielle Syntax zum Erstellen Schließungen. Blöcke werden nur in unterstützt MAC OS X 10.6 "Schneeleopard" oder später, iOS 4 oder später und gn .k Klang 3.1 oder höher.^[42]

#enthalten  #enthalten  Typedef int (^Intblock) (); Intblock Makecounter(int Anfang, int Zuwachs) {   __Block int i = Anfang;   Rückkehr Block_copy( ^ {   int ret = i;   i += Zuwachs;   Rückkehr ret;   }); } int hauptsächlich(Leere) {   Intblock Mycounter = Makecounter(5, 2);   printf("Erster Anruf: %d\n", Mycounter());   printf("Zweiter Anruf: %d\n", Mycounter());   printf("Dritter Anruf: %d\n", Mycounter());   / * Weil es kopiert wurde, muss es auch freigegeben werden */   Block_release(Mycounter);   Rückkehr 0; } /* Ausgabe:   Erster Anruf: 5   Zweiter Anruf: 7   Dritter Anruf: 9 */ 

Moderne Ziel-C

Apple hat im Laufe der Zeit einige zusätzliche Funktionen zu Objective 2.0 hinzugefügt. Die Ergänzungen gelten nur für den "Apfel Llvm Compiler ", d. H. Clang Frontend der Sprache. Verwirrend unterscheidet sich die von Apple verwendete Versions Xcode § Toolchain -Versionen Für eine Übersetzung zu Open-Source LLVM-Versionsnummern.^[43]

Automatische Referenzzählung

Die automatische Referenzzählung (ARC) ist eine Kompilierungszeitfunktion, die die Notwendigkeit von Programmierern beseitigt zuückbehalten und Veröffentlichung.^[44] nicht wie Müllsammlung, was zur Laufzeit auftritt, beseitigt den Overhead eines separaten Prozess, der die Zahlungszählungen verwaltet. Bogen- und Manual Memory Management schließen sich nicht gegenseitig aus. Programmierer können weiterhin Non-ARC-Code in Lichtbogen-fähigen Projekten verwenden, indem sie ARC für einzelne Codedateien deaktivieren. Xcode kann auch versuchen, ein Projekt automatisch auf ARC zu aktualisieren.

ARC wurde in LLVM 3.0 eingeführt. Dies führt zu Xcode 4.2 (2011) oder Apple LLVM Compiler 3.0.^[45]

Literale

Als nächstes und Apple OBJ-C-Laufzeit @"Ein neuer String", oder fallen auf CoreFoundation Constanten ab KCFBOOLEANTRUE und KCFBOOLEANFALSE zum Nsnumber mit booleschen Werten. Die Verwendung dieses Formats speichert dem Programmierer die längere Verwendung initWithString oder ähnliche Methoden bei bestimmten Operationen.

Bei Verwendung von Apple Llvm Compiler 4.0 (Xcode 4.4) oder höher, Arrays, Wörterbücher und Zahlen (Zahlen (Nsarray, NSDictionary, Nsnumber Klassen) können auch unter Verwendung der wörtlichen Syntax anstelle von Methoden erstellt werden.^[46] (Apple LLVM Compiler 4.0 übersetzt Open Source LLVM und Clang 3.1.)^[47]

Beispiel ohne Literale:

Nsarray *myarray = [Nsarray ArrayWithObjects:Objekt1,Objekt2,Objekt3,Null]; NSDictionary *MyDictionary1 = [NSDictionary DictionaryWithObject:ein bisschen objekt Forkey:@"Schlüssel"]; NSDictionary *MyDictionary2 = [NSDictionary DictionaryWithObjectsandkeys:Objekt1, Key1, Objekt2, Key2, Null]; Nsnumber *meine Nummer = [Nsnumber Nummer:myint]; Nsnumber *MySumnumber= [Nsnumber Nummer:(2 + 3)]; Nsnumber *MyBoolNumber = [Nsnumber NUMBERWITHBOOL:JAWOHL]; 

Beispiel mit Literalen:

Nsarray *myarray = @[ Objekt1, Objekt2, Objekt3 ]; NSDictionary *MyDictionary1 = @{{ @"Schlüssel" : ein bisschen objekt }; NSDictionary *MyDictionary2 = @{{ Key1: Objekt1, Key2: Objekt2 }; Nsnumber *meine Nummer = @(myint); Nsnumber *MySumnumber = @(2+3); Nsnumber *MyBoolNumber = @JAWOHL; Nsnumber *myinnernumber = @8; 

Anders als anders als String -LiteraleDiese Literale kompilieren zu Konstanten in der ausführbaren Datei, um den oben genannten Methodenaufrufen zu codieren. Insbesondere unter manuell referenzübergreifender Speicherverwaltung sind diese Objekte autorelea, was eine zusätzliche Sorgfalt erfordert, wenn z. B. mit Funktionsstatikvariablen oder anderen Arten von Globalen verwendet wird.

Abonnement

Bei Verwendung von Apple Llvm Compiler 4.0 oder höher, Arrays und Wörterbücher (Nsarray und NSDictionary Klassen) können mit Abonnement manipuliert werden.^[46] Abonnements kann verwendet werden, um Werte aus Indizes (Array) oder Schlüssel (Wörterbuch) abzurufen, und mit veränderlichen Objekten können auch Objekte auf Indizes oder Tasten festgelegt werden. In Code wird das Abonnement mit Klammern dargestellt [ ].^[48]

Beispiel ohne Abonnement:

Ich würde Objekt1 = [Somearray ObjectatIndex:0]; Ich würde Objekt2 = [Eines Tages ObjectForkey:@"Schlüssel"]; [Somemutablearray ersetzenObjectatIndex:0 withObject:Objekt3]; [Somemutabledictionary setObject:Objekt4 Forkey:@"Schlüssel"]; 

Beispiel mit Abonnement:

Ich würde Objekt1 = Somearray[0]; Ich würde Objekt2 = Eines Tages[@"Schlüssel"]; Somemutablearray[0] = Objekt3; Somemutabledictionary[@"Schlüssel"] = Objekt4; 

"Modern" Objective-C-Syntax (1997)

Nach dem Kauf von Apple von Apple wurden Versuche unternommen, die Sprache für Programmierer akzeptabler zu machen Java als smalltalk. Einer dieser Versuche bestand darin^[49] (im Gegensatz zur aktuellen "klassischen" Syntax). Es gab keine Verhaltensänderung, dies war lediglich eine alternative Syntax. Anstatt einen Methodenaufruf zu schreiben wie wie

  Objekt = [[Meine Klasse Alloc] drin];   [Objekt FirstLabel: Param1 SecondLabel: Param2]; 

Es wurde stattdessen als geschrieben als

  Objekt = (Meine Klasse.Alloc).drin;   Objekt.Etiketten ( Param1, Param2 ); 

In ähnlicher Weise gingen die Deklarationen aus der Form

  -(Leere) FirstLabel: (int)Param1 SecondLabel: (int)Param2; 

zu

  -(Leere) Etiketten ( int Param1, int Param2 ); 

Diese "moderne" Syntax wird nicht mehr in aktuellen Dialekten der Objektiv-C-Sprache unterstützt.

Mulle-Objc

Das Mulle-Objc Das Projekt ist eine weitere Neuimplementierung von Objective-C. Es unterstützt GCC oder Klang/Llvm Compiler als Backends. Es weicht von anderen Laufzeiten in Bezug auf Syntax, Semantik und Abi -Kompatibilität ab. Es unterstützt Linux, FreeBSD und Windows.

Tragbarer Objekt Compiler

neben dem GCC/Nächste/Apfel Implementierung, die dem Original mehrere Erweiterungen hinzufügte Schrittstein Implementierung, eine andere Kostenlose, offene Source Die Ziel-C-Implementierung, die als tragbarer Objekt Compiler bezeichnet wird, existiert auch.^[50] Der vom tragbare Objekt Compiler implementierte Satz von Erweiterungen unterscheidet sich von der Implementierung von GCC/Next/Apple. Insbesondere schließt es ein Smalltalk-Sähnliche Blöcke für Objektiv-C, während es keine Protokolle und Kategorien gibt, zwei Merkmale, die ausgiebig in OpenStep und seinen Derivaten und Verwandten verwendet werden. Insgesamt repräsentiert POC eine ältere Vorinstufe in der Entwicklung der Sprache, die grob mit dem Buch von Brad Cox von 1991 entspricht.

Es enthält außerdem eine Laufzeitbibliothek namens ObjectPak, die auf der ursprünglichen ICPAK101-Bibliothek von Cox (die wiederum von der SmallTalk-80-Klassenbibliothek stammt) und unterscheidet sich sehr radikal von der OpenStep FoundationKit.

GEOS-Ziel-C

Das PC -Geos System verwendete eine Programmiersprache GEOS-Ziel-C oder Goc;^[51] Trotz der Ähnlichkeit der Namen sind die beiden Sprachen nur im Gesamtkonzept und die Verwendung von Schlüsselwörtern ähnlich, die mit einem @ -Schark vorangestellt sind.

Klang

Das Klang Compiler Suite, Teil der Llvm Projekt, implementiert objektive C und andere Sprachen. Nachdem GCC 4.3 (2008) auf GPLV3 gewechselt war, hat Apple es zugunsten von Clang aufgegeben, einem Compiler, der mehr rechtliche Befugnisse hat, um zu ändern. Infolgedessen werden viele der modernen Objektivsprachenmerkmale nur von Clang unterstützt.

Das Versionsschema von Apple für den Clang-basierten "LLVM Compiler" unterscheidet sich von der Open-Source-Versionierung der LLVM. Sehen Xcode § Toolchain -Versionen für eine Übersetzung^[43]

Gnu, Gn .- und Winobjc

Das GNU-Projekt hat sich seit langer Zeit an einer Plattform interessiert, um als nächstes und OBJ-C-Programme zu portieren. Der Changelog für die libobjc Das Verzeichnis in GCC schlägt vor, dass es vor 1998 (GCC 2.95) und seine Readme im Jahr 1993 weiterhin auf eine Umschreibung (GCC 2.4) vorhanden ist.^[52]

Der nächste Frontend -Quellcode wurde veröffentlicht, da er im Rahmen von GCC veröffentlicht wurde, veröffentlicht wurde GNU Public Lizenz Was diejenigen zwingt, die abgeleitete Werke machen, um dies zu tun.^[wenn?] Apple setzte diese Tradition fort, ihre GCC -Gabel bis zu 4.2.1 zu veröffentlichen, woraufhin sie den Compiler verlassen hatten. GCC-Betreuer nahmen die Veränderungen an, investierten jedoch nicht viel in die Unterstützung neuerer Merkmale wie der Sprache für objektive C 2.0.^{[32]: Welcher Compiler}

Die GNUSTEP -Entwickler, die an der neuen Sprache interessiert sind, gaben den GCC auf libobjc zu einem Projekt unabhängig von GCC genannt libobjc2 Im Jahr 2009 arrangierten sie auch die Laufzeit mit Clang, um die neue Sprachsyntax zu nutzen.^{[32]: Welcher Compiler} GCC bewegte sich langsam zur gleichen Zeit, aber bei GCC 4.6.0 (2011) haben sie sich auch in ihrem Libobjc zu Objective-C 2.0 übergegangen.^[31][53] Die Dokumentation der GNUSTEP-Dokumentation legen nahe, dass die GCC-Implementierung immer noch die Unterstützung für Blöcke, nicht-fragile Variablen und den neueren Bogen fehlt.^{[32]: Welche Laufzeit}

Microsoft gegabelt libobjc2 in einen Teil von Winobjc, die iOS -Brücke für Universelle Windows -Plattform, im Jahr 2015. kombiniert mit einer eigenen Umsetzung von Kakao -Berührung und zugrunde liegende APIs ermöglicht das Projekt die Wiederverwendung von iOS -Anwendungscode in UWP -Apps.^[54]

Unter Windows werden Objektiv-C-Entwicklungstools zum Download auf der Website von GNUSTEP zur Verfügung gestellt. Das GNUSTEP -Entwicklungssystem besteht aus den folgenden Paketen: Gn .pep MSYS System, Gn .pep -Kern, Gn .pep Devel, Gn. -Kairo, ProjectCenter IDE (wie Xcode, aber nicht als komplex), GORM (Schnittstellenbauer wie Xcode NIB Builder). Diese binären Installateure wurden seit 2016 nicht mehr aktualisiert.^[55] Es könnte also eine bessere Idee sein, nur durch das Gebäude unter Gebäude zu installieren Cygwin oder MSYS2 stattdessen.

Bibliotheksgebrauch

Objective-C wird heute häufig zusammen mit einer festen Bibliothek von Standardobjekten (oft als "Kit" oder "Framework" bezeichnet) wie z. Kakao, Gn .p oder objfw. Diese Bibliotheken kommen oft mit dem Betriebssystem Linux-Basierte Verteilungen und Kakao sind mit MacOS geliefert. Der Programmierer ist nicht gezwungen, die Funktionalität aus der vorhandenen Basisklasse (NSObject / OfObject) zu erben. Objective-C ermöglicht die Erklärung neuer Stammklassen, die keine vorhandenen Funktionen erben. Ursprünglich boten objektive C-basierte Programmierumgebungen in der Regel eine Objektklasse als Basisklasse, von der fast alle anderen Klassen geerbt wurden. Mit der Einführung von OpenStep erstellte als nächstes eine neue Basisklasse mit dem Namen NSObject, die zusätzliche Funktionen über das Objekt bot (eine Betonung der Verwendung von Objektreferenzen und Referenzzählung anstelle von Rohzeigern z. B.). Fast alle Klassen in Kakao erben von NSObject.

Das Umbenennen diente nicht nur dazu, das neue Standardverhalten von Klassen innerhalb der OpenStep-API zu unterscheiden, sondern auch Code, das Objekt verwendet hat-die ursprüngliche Basisklasse, die auf NextStep verwendet wurde (und mehr oder weniger andere Bibliotheken für objektive C-Klassen)-zu Koexistiere in derselben Laufzeit mit Code, der NSObject verwendet hat (mit einigen Einschränkungen). Die Einführung des beiden Buchstabenpräfixes wurde auch zu einer simplen Form von Namespaces, die Objective-C fehlt. Die Verwendung eines Präfixes zum Erstellen einer informellen Verpackungskennung wurde zu einem informellen Codierungsstandard in der Objektiv-C-Community und dauert bis heute fort.

In jüngerer Zeit erscheinen Paketmanager, wie z. Cocoapods, der sowohl ein Paketmanager als auch ein Repository von Paketen sein soll. Viele Open-Source-Objektivcode, der in den letzten Jahren geschrieben wurde, können jetzt mit Cocoapods installiert werden.

Analyse der Sprache

Objektiv-C-Implementierungen verwenden ein dünn Laufzeitsystem Geschrieben in C, was der Größe der Anwendung wenig hinzufügt. Im Gegensatz dazu benutzte die meisten objektorientierten Systeme zum Zeitpunkt der Erstellung großer virtuelle Maschine Laufzeiten. Programme, die in Objective-C geschrieben wurden, sind in der Regel nicht viel größer als die Größe ihres Codes und der der Bibliotheken (die im Gegensatz zu SmallTalk-Systemen, in denen eine große Menge an Speicher war verwendet nur, um ein Fenster zu öffnen. Objective-C-Anwendungen sind in der Regel größer als ähnliche C- oder C ++-Anwendungen, da die dynamische Typisierung von Objektiv-C nicht zulässt, dass die Methoden strippiert oder eingegeben werden. Da der Programmierer eine solche Freiheit hat, um zu delegieren, Anrufe zu leiten, Selektoren im laufenden Fliegen zu erstellen und an das Laufzeitsystem weiterzugeben, kann der Objektiv-C-Compiler nicht davon ausgehen, dass es sicher ist, nicht verwendete Methoden zu entfernen oder Anrufe zu inline.

Ebenso kann die Sprache auf vorhandenen C -Compilern implementiert werden (in GCC, zuerst als Präprozessor, dann eher als Modul) als als neuer Compiler. Dies ermöglicht das Ziel von Objective-C, die enorme vorhandene Sammlung von C-Code, Bibliotheken, Tools usw. zu nutzen Wrapper zur Bereitstellung einer Schnittstelle im OO-Stil. In dieser Hinsicht ist es ähnlich wie Gobject Bibliothek und Vala Sprache, die in der Entwicklung von weit verbreitet sind Gtk Anwendungen.

All diese praktischen Veränderungen senkten die Zutrittsschranke, wahrscheinlich das größte Problem für die weit verbreitete Akzeptanz von SmallTalk in den 1980er Jahren.

Eine häufige Kritik ist, dass Objective-C keine Sprachunterstützung für die Sprache hat Namespaces. Stattdessen sind Programmierer gezwungen, ihren Klassennamen Präfixe hinzuzufügen, die traditionell kürzer sind als Namespace -Namen und somit anfälliger für Kollisionen. Ab 2007 alle MacOS -Klassen und -funktionen in der Kakao Die Programmierumgebung wird mit "NS" (z. B. NSObject, NSButton) vorangestellt, um sie als zum MacOS- oder iOS -Kern zu identifizieren. Das "NS" leitet sich aus den Namen der Klassen ab, wie sie während der Entwicklung von definiert sind Nächster Schritt.

Da Objective-C ein striktes Superet von C ist, behandelt es keine primitiven Typen als erstklassige Objekte.

nicht wie C ++, Objective-C unterstützt nicht Bedienerüberlastung. Auch im Gegensatz zu C ++ ermöglicht Objective-C ein Objekt, nur von einer Klasse direkt zu erben (verbieten Mehrfacherbe). In den meisten Fällen können jedoch Kategorien und Protokolle als alternative Möglichkeiten verwendet werden, um dieselben Ergebnisse zu erzielen.

Da Objective-C dynamische Laufzeit-Typisierung verwendet und weil alle Methodenaufrufe Funktionsaufrufe sind (oder in einigen Fällen in Syscalls), können viele gemeinsame Leistungsoptimierungen nicht auf Objective-C-Methoden angewendet werden (z. und skalarer Austausch von Aggregaten). Dies begrenzt die Leistung von Objektiv-C-Abstraktionen in Bezug auf ähnliche Abstraktionen in Sprachen wie C ++, bei denen solche Optimierungen möglich sind.

Speicherverwaltung

Die ersten Versionen von Objective-C unterstützten nicht Müllsammlung. Zu dieser Zeit war diese Entscheidung eine Frage einer Debatte, und viele Menschen betrachteten lange "tote Zeiten" (als SmallTalk eine Sammlung durchführte), um das gesamte System unbrauchbar zu machen. Einige Drittanbieter -Implementierungen haben diese Funktion hinzugefügt (vor allem Gn. Gn. Boehm), und Apple hat es als von implementiert Mac OS X v10.5.^[56] In neueren Versionen von MacOS und iOS wurde die Müllsammlung jedoch zugunsten von veraltet Automatische Referenzzählung (ARC), eingeführt 2011.

Mit ARC fügt der Compiler-Einfüge auf, Anrufe automatisch in den Objektiv-C-Code basierend aufzubehalten und freizugeben Statische Codeanalyse. Die Automatisierung entlastet den Programmierer, in Speicherverwaltungscode zu schreiben. ARC fügt auch schwache Hinweise auf die Zielsprache für Objektiv-C hinzu.^[57]

Philosophische Unterschiede zwischen Objektiv-C und C ++

Das Design und die Implementierung von C ++ und Objective-C repräsentieren grundsätzlich unterschiedliche Ansätze zur Erweiterung von C.

Zusätzlich zu Cs Verfahrensprogrammierung unterstützt C ++ bestimmte Formen von direkt Objekt orientierte Programmierung, generische Programmierung, und Metaprogrammierung. C ++ kommt auch mit Eine große Standardbibliothek das schließt sich ein Mehrere Containerklassen. In ähnlicher Weise fügt Objective-C hinzu Objekt orientierte Programmierung, Dynamisches Typing, und Betrachtung Zu C. Objective-C bietet keine Standardbibliothek an sich, aber an den meisten Orten, an denen Objective-C verwendet wird, wird es mit einem verwendet OpenStep-ähnliche Bibliothek wie z. OpenStep, Kakao, oder Gn .p, was eine Funktionalität bietet, die der Standardbibliothek von C ++ ähnelt.

Ein bemerkenswerter Unterschied besteht darin, dass Objective-C Laufzeitunterstützung für reflektierend Merkmale, während C ++ in Objektiv-C nur eine kleine Menge an Laufzeitunterstützung hinzufügt, kann ein Objekt über seine eigenen Eigenschaften abgefragt werden, z. B. unabhängig davon, ob es auf eine bestimmte Nachricht reagiert. In C ++ ist dies ohne die Verwendung externer Bibliotheken nicht möglich.

Die Verwendung von Reflexion ist Teil der umfassenderen Unterscheidung zwischen dynamischen (Laufzeit-) Merkmalen und statischen (Kompilierungszeit-) Merkmalen einer Sprache. Obwohl Objective-C und C ++ jeweils eine Mischung aus beiden Merkmalen verwenden, ist Objective-C entschieden auf Laufzeitentscheidungen ausgerichtet, während C ++ auf Kompilierungszeitentscheidungen ausgerichtet ist. Die Spannung zwischen dynamischer und statischer Programmierung beinhaltet viele der klassischen Kompromisse in der Programmierung: Dynamische Funktionen verleihen Flexibilität, statische Merkmale hinzufügen Geschwindigkeit und Typprüfung.

Generische Programmierung und Metaprogrammierung kann in beiden Sprachen verwendet werden Laufzeitpolymorphismus. In C ++ nimmt dies die Form von an Virtuelle Funktionen und Identifizierung von Laufzeittyp, während objektive C dynamische Typisierung und Reflexion bietet. Sowohl Objective-C- als auch C ++ -Strägungs-Kompilierungs-Zeit-Polymorphismus (generische Funktionen), wobei Objective-C nur diese Funktion 2015 hinzufügt.

Siehe auch

• C (Programmiersprache)
• C ++
• Vergleich der Programmiersprachen
• Vergleich mit COM, Gobject, Som, Windows Runtime, XPCOM
• Schnell (Programmiersprache)
• Xcode
• Winobjc (AKA: Windows Bridge für iOS)

Verweise

Weitere Lektüre

Externe Links

• Programmierung mit Objektiv-C, von Apple (2012-12-13)
• Die Zielsprache für Ziele-C, von Apple (2011-10-11)
• Objektiv-C-Laufzeit-Programmierhandbuch, von Apple (2009-10-19)
• Objective-C GNUSTEP-Basisprogrammierhandbuch
• Objektiv-C von Brad Cox
• Ziel-C-FAQ