Ziel-C ist eine reflektierende, objektorientierte Programmiersprache, die mit dem Plausch artige Nachrichtenübermittlung zur C Programmiersprache hinzufügt.

Heute wird es in erster Linie auf Mac OS X des Apfels und EIN/AUSGABE-STEUERSYSTEM verwendet: Zwei Umgebungen sind auf den Standard von OpenStep, obwohl nicht entgegenkommend damit zurückzuführen gewesen. Ziel-C ist die primäre Sprache, die für die Kakao-API des Apfels verwendet ist, und es war ursprünglich die Hauptsprache auf NeXTSTEP von NeXT Betriebssystem. Allgemeine Objektive-C Programme, die diese Bibliotheken nicht verwenden, können auch für jedes System kompiliert werden, das durch gcc oder Klappern unterstützt ist.

Geschichte

Ziel-C wurde in erster Linie von Brad Cox und Tom Love am Anfang der 1980er Jahre an ihrer Gesellschaft Stepstone geschaffen. Beide waren in den Plausch während am Programmiertechnologiezentrum von ITT Corporation 1981 vorgestellt worden. Die frühste Arbeit an Objektiven-C Spuren zurück zu ungefähr dieser Zeit.

Steuermann wurde durch Probleme der wahren Wiederverwendbarkeit im Softwaredesign und der Programmierung gefesselt. Er hat begriffen, dass eine Sprache wie Plausch im Gebäude von Entwicklungsumgebungen für Systementwickler an ITT unschätzbar sein würde. Jedoch haben er und Tom Love auch anerkannt, dass die rückwärts gerichtete Vereinbarkeit mit C im Telekommunikationstechnikmilieu von ITT kritisch wichtig war.

Steuermann hat begonnen, einen Vorverarbeiter für C zu schreiben, um einige der Fähigkeiten zum Plausch hinzuzufügen. Er hatte bald eine Arbeitsdurchführung einer objektorientierten Erweiterung in die c Sprache, die er "OOPC" nach dem Objektorientierten Vorübersetzer genannt hat.

Liebe wurde durch die Schlumberger Forschung 1982 gemietet und hatte die Gelegenheit, die erste kommerzielle Kopie des Plausches 80 zu erwerben, der weiter die Entwicklung ihres Geistesproduktes beeinflusst hat.

Um zu demonstrieren, dass echte Fortschritte gemacht werden konnten, hat Cox gezeigt, dass das Bilden austauschbarer Softwarebestandteile wirklich nur einige praktische Änderungen zu vorhandenen Werkzeugen gebraucht hat. Spezifisch mussten sie Gegenstände auf eine flexible Weise unterstützen, kommen Sie versorgt mit einem verwendbaren Satz von Bibliotheken, und berücksichtigen Sie den Code (und irgendwelche Mittel, die durch den Code erforderlich sind), um in ein einzelnes Quer-Plattform-Format gestopft zu werden.

Liebe und Cox haben schließlich ein neues Wagnis, Productivity Products International (PPI) gebildet, um ihr Produkt zu kommerzialisieren, das einen Objektiven-C Bearbeiter mit Klassenbibliotheken verbunden hat. 1986 hat Cox die Hauptbeschreibung des Ziels-C in seiner ursprünglichen Form im Buch Objektorientierte Programmierung, Eine Entwicklungsannäherung veröffentlicht. Obwohl er darauf geachtet hat darauf hinzuweisen, dass es mehr zum Problem der Wiederverwendbarkeit gibt als gerade die Sprache, hat sich Ziel-C häufig verglichene Eigenschaft für die Eigenschaft mit anderen Sprachen gefunden.

Popularisierung durch NeXT

Nachdem Steve Jobs Apple Inc. verlassen hat, hat er die Gesellschaft NeXT angefangen. 1988 hat NeXT Ziel-C von StepStone (der neue Name von PPI, der Eigentümer der Objektiven-C Handelsmarke) lizenziert und hat den GCC Bearbeiter erweitert, um Ziel-C zu unterstützen, und hat die Bibliotheken von AppKit und Foundation Kit entwickelt, auf denen der Benutzerschnittstelle- und Schnittstelle-Baumeister von NeXTstep basiert haben. Während die Arbeitsplätze von NeXT gescheitert haben, einen großen Einfluss im Marktplatz zu machen, wurden die Werkzeuge in der Industrie weit gelobt. Das hat NeXT dazu gebracht, Hardware-Produktion fallen zu lassen und sich auf Softwarewerkzeuge zu konzentrieren, NeXTstep (und OpenStep) als eine Plattform für die kundenspezifische Programmierung verkaufend.

Das GNU-Projekt hat Arbeit an seinem freien Klon von NeXTStep, genannt GNUstep angefangen, der auf dem Standard von OpenStep gestützt ist. Dennis Glatting hat die erste GNU-Durchlaufzeit des Ziels-C 1992 geschrieben. Die GNU-Durchlaufzeit des Ziels-C, die im Gebrauch seit 1993 gewesen ist, ist von Kresten Krab Thorup entwickelte diejenige, als er ein Universitätsstudent in Dänemark war. Thorup hat auch an NeXT von 1993 bis 1996 gearbeitet.

Nach dem Erwerben von NeXT 1996 hat Apple Computer OpenStep in seinem neuen Betriebssystem, Mac OS X verwendet. Dieses eingeschlossene Ziel-C und das Ziel-C von NeXT haben Entwickler-Werkzeug, Projektbaumeister gestützt (der ausgebreitet worden war und jetzt Xcode genannt wird), sowie sein Schnittstelle-Designwerkzeug, Schnittstelle-Baumeister. Der grösste Teil der heutigen Kakao-API des Apfels basiert auf Schnittstelle-Gegenständen von OpenStep, und ist die bedeutendste Objektive-C Umgebung, die für die aktive Entwicklung wird verwendet.

Syntax

Ziel-C ist eine dünne Schicht oben auf C, und ist außerdem eine strenge Obermenge von C; es ist möglich, jedes C Programm mit einem Objektiven-C Bearbeiter zu kompilieren, und C-Code innerhalb einer Objektiven-C Klasse frei einzuschließen.

Ziel-C leitet seine Gegenstand-Syntax vom Plausch ab. Die ganze Syntax für nichtobjektorientierte Operationen (einschließlich primitiver Variablen, Aufbereitung, Ausdrücke, Funktionsbehauptungen und Funktionsanrufe) ist zu diesem von C identisch, während die Syntax für objektorientierte Eigenschaften eine Durchführung der mit dem Plausch artigen Nachrichtenübermittlung ist.

Nachrichten

Das Objektive-C Modell der objektorientierten Programmierung basiert auf der Nachricht, die zu Gegenstand-Beispielen geht. Im Ziel-C nennt man keine Methode einfach; man sendet eine Nachricht. Das ist verschieden vom Simula-artigen Programmiermodell, das durch C ++ verwendet ist. Der Unterschied zwischen diesen zwei Konzepten ist darin, wie der Code, der durch die Methode oder den Nachrichtennamen Verweise angebracht ist, durchgeführt wird. Auf einer Simula-artigen Sprache ist der Methode-Name in den meisten Fällen, die zu einer Abteilung des Codes in der Zielklasse durch den Bearbeiter gebunden sind. Im Plausch und Ziel-C wird das Ziel einer Nachricht an der Durchlaufzeit mit dem Empfang-Gegenstand aufgelöst, selbst die Nachricht interpretierend. Eine Methode wird von einem Auswählenden oder — - begrenzter Schnur identifiziert, die seinen Namen vertritt — und zu einem C Methode-Zeigestock aufgelöst, der ihn durchführt:. Eine Folge davon ist, dass das nachrichtenpassierende System keine Datentypprüfung hat. Wie man versichert, antwortet der Gegenstand, zu dem die Nachricht — der Empfänger geleitet wird — auf eine Nachricht nicht, und wenn es nicht tut, erhebt es einfach eine Ausnahme.

Das Senden der Nachricht an den Gegenstand, der auf durch den Zeigestock angespitzt ist, würde den folgenden Code in C ++ verlangen:

Im Ziel-C wird das wie folgt geschrieben:

Sowohl Stile der Programmierung haben ihre Kräfte als auch Schwächen. Die objektorientierte Programmierung im Stil von Simula erlaubt Mehrfachvererbungen und schnellere Ausführung durch das Verwenden der Übersetzungszeit, wann immer möglich bindend, aber es unterstützt dynamische Schwergängigkeit standardmäßig nicht. Es zwingt auch alle Methoden, eine entsprechende Durchführung zu haben, wenn sie nicht virtuell sind, bedeutend, dass die Methode ein Platzhalter für Methoden mit demselben in Gegenständen zu definierenden Namen ist, ist auf den Grundgegenstand zurückzuführen gewesen. Mit dem Plausch artige Programmierung erlaubt Nachrichten, undurchgeführt mit der Methode zu gehen, die zu seiner Durchführung an der Durchlaufzeit aufgelöst ist. Zum Beispiel kann eine Nachricht an eine Sammlung von Gegenständen gesandt werden, zu denen, wie man erwarten wird, nur einige, ohne Angst davor antworten werden, Laufzeitfehler zu erzeugen. Nachricht, die auch geht, verlangt nicht, dass ein Gegenstand während der Übersetzung definiert wird. Eine Durchführung ist noch für die Methode erforderlich, der abgeleitete Gegenstand herbeigerufen zu werden. (Sieh das dynamische Abteilung unten für mehr Vorteile der dynamischen (späten) Schwergängigkeit tippen.)

Schnittstellen und Durchführungen

Ziel-C verlangt, dass die Schnittstelle und Durchführung einer Klasse in getrennt offen erklärten Codeblöcken sind. Durch die Tagung legen Entwickler die Schnittstelle in eine Kopfball-Datei und die Durchführung in einer Codedatei. Die Kopfball-Dateien, normalerweise suffixed.h, sind C Kopfball-Dateien ähnlich, während die Durchführung (Methode) Dateien, normalerweise suffixed.m, C-Codedateien sehr ähnlich sein kann.

Schnittstelle

Die Schnittstelle einer Klasse wird gewöhnlich in einer Kopfball-Datei definiert. Eine allgemeine Tagung ist, die Kopfball-Datei nach dem Namen der Klasse zu nennen, z.B würde die Schnittstelle für die Klasse enthalten.

Eine Schnittstelle-Behauptung nimmt die Form an:

@interface classname: superclassname {\

//Beispiel-Variablen

}\

+ classMethod1;

+ (return_type) classMethod2;

+ (return_type) classMethod3: (param1_type) param1_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

</syntaxhighlight>

</Spanne>

Im obengenannten zeigen Pluszeichen Klassenmethoden an, oder Methoden, die auf der Klasse selbst (nicht auf einem Beispiel), und minus Zeichen genannt werden können, zeigen Beispiel-Methoden an, die nur auf einem besonderen Beispiel der Klasse genannt werden können. Klassenmethoden haben auch keinen Zugang zu Beispiel-Variablen.

Der Code ist oben zum folgenden C ++ Schnittstelle grob gleichwertig:

Klasse classname: Publikum superclassname {\

geschützt:

//Beispiel-Variablen

Publikum:

//Klasse (statische) Funktionen

statische Leere * classMethod1 ;

statischer return_type classMethod2 ;

statischer return_type classMethod3 (param1_type param1_varName);

//Beispiel (Mitglied) fungiert

return_type instanceMethod1

(param1_type param1_varName, param2_type param2_varName);

return_type instanceMethod2WithParameter

(param1_type param1_varName, param2_type param2_varName=default);

};

</syntaxhighlight></Spanne>

Bemerken Sie, dass das das Durchschießen von Auswählender-Segmenten mit Argument-Ausdrücken demonstriert, für die es keine direkte Entsprechung in C/C ++ gibt.

Kehren Sie zurück Typen können jeder Standardtyp C, ein Zeigestock zu einem allgemeinen Objektiven-C Gegenstand oder ein Zeigestock zu einem spezifischen Typ des Gegenstands wie NSArray *, NSImage *, oder NSString * sein. Der Verzug-Rücktyp ist der allgemeine Typ Objective-C.

Methode-Argumente beginnen mit einem Doppelpunkt, der vom erwarteten Argument-Typ in Parenthesen und dem Argument-Namen gefolgt ist. In einigen Fällen (z.B, wenn man System APIs schreibt), ist es nützlich, beschreibenden Text vor jedem Parameter hinzuzufügen.

- (Leere) setRangeStart: (int) Anfang-Ende: (int) Ende;

- (Leere) importDocumentWithName: (NSString *) nennen withSpecifiedPreferences:

(Einstellungen *) prefs beforePage: (interne Nummer) insertPage;

</syntaxhighlight></Spanne>

Durchführung

Die Schnittstelle erklärt nur die Klassenschnittstelle und nicht die Methoden selbst: Der wirkliche Code wird in der Durchführungsdatei geschrieben. Durchführung (Methode) Dateien haben normalerweise die Dateierweiterung, die ursprünglich "Nachrichten" bedeutet hat.

@implementation classname

+ (return_type) classMethod {\

//Durchführung

}\

- (return_type) instanceMethod {\

//Durchführung}\@end</syntaxhighlight></Spanne>

Methoden werden mit ihren Schnittstelle-Behauptungen geschrieben.

Das Vergleichen des Ziels-C und C:

- (int) Methode: (interne Nummer) ich {\

kehren Sie [selbst square_root:i] zurück;

}\</syntaxhighlight></Spanne>

int Funktion (interne Nummer i) {\

geben Sie square_root (i) zurück;

}\</syntaxhighlight></Spanne>

Die Syntax erlaubt, von Argumenten pseudozunennen.

[myColor changeColorToRed:5.0 green:2.0 blue:6.0];

</syntaxhighlight></Spanne>

Innere Darstellungen einer Methode ändern sich zwischen verschiedenen Durchführungen des Ziels-C. Wenn myColor der Klasse ist, könnte Beispiel-Methode innerlich etikettiert werden. Zu sein, um sich auf eine Beispiel-Methode, mit der Klasse und dann den Methode-Namen angehangen und Doppelpunkte zu beziehen, die dazu geändert sind, unterstreicht. Da die Ordnung von Rahmen ein Teil des Methode-Namens ist, kann es nicht geändert werden, um Codierstil oder Ausdruck als mit wahren genannten Rahmen anzupassen.

Jedoch werden innere Namen der Funktion direkt selten verwendet. Allgemein werden Nachrichten zu in der Objektiven-C Laufzeitbibliothek definierten Funktionsanrufen umgewandelt. Es ist in der Bindezeit nicht notwendigerweise bekannt, die Methode genannt wird, weil die Klasse des Empfängers (der Gegenstand, der die Nachricht wird sendet), bis zur Durchlaufzeit nicht bekannt zu sein braucht.

Instantiation

Sobald eine Objektive-C Klasse geschrieben wird, kann sie realisiert werden. Das wird durch das erste Zuteilen eines uninitialisierten Beispiels der Klasse (ein Gegenstand) und dann durch das Initialisieren davon getan. Ein Gegenstand ist nicht völlig funktionell, bis beide Schritte vollendet worden sind. Diese Schritte sollten mit einer einzelnen Linie des Codes vollbracht werden, so dass es nie einen zugeteilten Gegenstand gibt, der Initialisierung nicht erlebt hat (und weil es nicht ratsam ist, das Zwischenergebnis zu behalten, da einen verschiedenen Gegenstand zurückgeben kann als das, was es aufgefordert wird).

Instantiation mit dem Verzug, Initialisierungsprogramm ohne Parameter:

Instantiation mit einem kundenspezifischen Initialisierungsprogramm:

Im Fall, wo keine kundenspezifische Initialisierung durchgeführt wird, kann die "neue" Methode häufig im Platz der alloc-init Nachrichten verwendet werden:

Die alloc Nachricht teilt genug Gedächtnis zu, um alle Beispiel-Variablen für einen Gegenstand zu halten, setzt alle Beispiel-Variablen auf Nullwerte, und verwandelt das Gedächtnis in ein Beispiel der Klasse; an nichts während der Initialisierung ist das Gedächtnis ein Beispiel der Superklasse.

Die init Nachricht führt die Einstellung des Beispiels nach der Entwicklung durch. Die init Methode wird häufig wie folgt geschrieben:

- (id) init {\

selbst = [fantastischer init];

wenn (selbst) {\

//führen Sie Initialisierung des Gegenstands hier durch

}\

kehren Sie selbst zurück;

}\

</syntaxhighlight>

Im obengenannten Beispiel, bemerken Sie den Rücktyp. Dieser Typ tritt "für Zeigestock zu jedem Gegenstand" im Ziel-C ein (Sieh das Dynamische Abteilung tippen).

Das Initialisierungsprogramm-Muster wird verwendet, um zu versichern, dass der Gegenstand durch seine Superklasse richtig initialisiert wird, bevor die init Methode seine Initialisierung durchführt. Es führt die folgenden Handlungen durch:

1. selbst = [fantastischer init]
2. : Sendet dem Superklassenbeispiel eine init Nachricht und teilt das Ergebnis selbst (Zeigestock zum aktuellen Gegenstand) zu.
3. wenn (selbst)
4. : Kontrollen, wenn der zurückgegebene Gegenstand-Zeigestock vor dem Durchführen einer Initialisierung gültig ist.
5. kehren Sie selbst zurück
6. : Gibt den Wert selbst dem Anrufer zurück.

Ein nichtgültiger Gegenstand-Zeigestock hat die Wertnull; bedingte Behauptungen wie "wenn" die Vergnügen-Null wie ein ungültiger Zeigestock, so wird der Initialisierungscode nicht durchgeführt, wenn [fantastischer init] Null zurückgegeben hat. Wenn es einen Fehler in der Initialisierung gibt, sollte die init Methode jede notwendige Reinigung, einschließlich des Sendens einer "Ausgabe"-Nachricht an selbst durchführen, und Null zurückgeben, um anzuzeigen, dass Initialisierung gescheitert hat, muss irgendwelcher, für solche Fehler überprüfend, nur durchgeführt werden, die Superklasseninitialisierung genannt, um sicherzustellen, dass das Zerstören des Gegenstands richtig getan wird.

Wenn eine Klasse mehr als eine Initialisierungsmethode hat, müssen nur ein von ihnen (das "hingebungsvolle Initialisierungsprogramm") diesem Muster folgen; andere sollten das hingebungsvolle Initialisierungsprogramm statt des Superklasseninitialisierungsprogramms nennen.

Protokolle

Ziel-C wurde an Daneben erweitert führen das Konzept der Mehrfachvererbung der Spezifizierung, aber nicht Durchführung durch die Einführung von Protokollen ein. Das ist ein Muster erreichbar, entweder weil ein Auszug geerbte Grundklasse in C ++, oder als eine "Schnittstelle" (als in Java und C#) multipliziert. Ziel-C macht von genannten informellen Protokollen von Ad-Hoc-Protokollen Gebrauch, und Bearbeiter-beachtete Protokolle haben formelle Protokolle genannt.

Ein informelles Protokoll ist eine Liste von Methoden, die sich eine Klasse dafür entscheiden kann durchzuführen. Es wird in der Dokumentation angegeben, da es keine Anwesenheit auf der Sprache hat. Informelle Protokolle schließen häufig fakultative Methoden ein, die, wenn durchgeführt, das Verhalten einer Klasse ändern können. Zum Beispiel könnte eine Textfeldklasse einen Delegierten haben, der ein informelles Protokoll mit einer fakultativen Methode durchführt, um Autovollziehung des benutzergetippten Textes durchzuführen. Das Textfeld entdeckt, ob der Delegierte diese Methode (über das Nachdenken) durchführt und wenn so, die Methode des Delegierten nennt, die autoganze Eigenschaft zu unterstützen.

Ein formelles Protokoll ist einer Schnittstelle in Java oder C# ähnlich. Es ist eine Liste von Methoden, die sich jede Klasse erklären kann durchzuführen. Versionen des Ziels-C vorher 2.0 haben verlangt, dass eine Klasse alle Methoden in einem Protokoll durchführen muss, das es selbst als das Übernehmen erklärt; der Bearbeiter wird einen Fehler ausstrahlen, wenn die Klasse jede Methode aus seinen offen erklärten Protokollen nicht durchführt. Objektive-C 2.0 hinzugefügte Unterstützung, um bestimmte Methoden in einem Protokoll fakultativ, und der Bearbeiter zu kennzeichnen, wird Durchführung von fakultativen Methoden nicht geltend machen.

Das Objektive-C Konzept von Protokollen ist von Java oder C# Konzept von Schnittstellen verschieden, in denen eine Klasse ein Protokoll durchführen kann, ohne erklärt zu werden, dieses Protokoll durchzuführen. Der Unterschied ist von der Außenseite des Codes nicht feststellbar. Formelle Protokolle können keine Durchführungen zur Verfügung stellen, sie versichern einfach Anrufer, dass Klassen, die sich dem Protokoll anpassen, Durchführungen zur Verfügung stellen werden. In der NeXT / Apfel-Bibliothek werden Protokolle oft durch das Verteilte Gegenstand-System verwendet, um die Fähigkeiten zu einer Gegenstand-Durchführung auf einem entfernten System zu vertreten.

Die Syntax

@protocol, der Sich Schließen lässt

- (leeres) Schloss;

- (Leere) schließt auf;

@end</syntaxhighlight>

zeigt an, dass es die abstrakte Idee gibt sich schließen zu lassen. Durch das Feststellen, dass das Protokoll in der Klassendefinition durchgeführt wird:

@interface SomeClass: SomeSuperClass

@end</syntaxhighlight>

Beispiele von SomeClass behaupten, dass sie eine Durchführung für die zwei Beispiel-Methoden mit beliebigen Mitteln zur Verfügung stellen werden, die sie wählen. Ein anderer Beispiel-Gebrauch der abstrakten Spezifizierung beschreibt die gewünschten Handlungsweisen von Einfügefunktionen ohne zu beschränken, wie die Durchführungshierarchie sein sollte.

Das dynamische Schreiben

Ziel-C, wie Plausch, kann das dynamische Schreiben verwenden: Einem Gegenstand kann eine Nachricht gesandt werden, die in seiner Schnittstelle nicht angegeben wird. Das kann vergrößerte Flexibilität berücksichtigen, weil sie einem Gegenstand erlaubt, eine Nachricht "zu gewinnen" und die Nachricht an einen verschiedenen Gegenstand zu senden, der auf die Nachricht passend antworten, oder ebenfalls die Nachricht an einen anderen Gegenstand vorausschicken kann. Dieses Verhalten ist als Nachrichtenversand oder Delegation (sieh unten) bekannt. Wechselweise kann ein Fehlerdressierer verwendet werden, im Falle dass die Nachricht nicht nachgeschickt werden kann. Wenn ein Gegenstand keine Nachricht nachschickt, darauf antwortet, oder einen Fehler behandelt, wird die Nachricht still verworfen. Wenn Nachrichten an die Null gesandt werden (der ungültige Gegenstand-Zeigestock), werden sie still ignoriert oder eine allgemeine Ausnahme abhängig von Bearbeiter-Optionen erheben.

Statische tippende Information kann auch zu Variablen fakultativ hinzugefügt werden. Diese Information wird dann während der Übersetzung überprüft. In den folgenden vier Behauptungen wird immer spezifischere Typ-Auskunft gegeben. Die Behauptungen sind an der Durchlaufzeit gleichwertig, aber die Zusatzinformation erlaubt dem Bearbeiter, den Programmierer zu warnen, wenn das passierte Argument den angegebenen Typ nicht vergleicht.

- (Leere) setMyValue: (id) foo;

</syntaxhighlight>

In der obengenannten Behauptung kann foo von jeder Klasse sein.

- (Leere) setMyValue: (id

</syntaxhighlight>

In der obengenannten Behauptung kann foo ein Beispiel jeder Klasse sein, die sich dem aProtocol Protokoll anpasst.

- (Leere) setMyValue: (NSNumber *) foo;

</syntaxhighlight>

In der obengenannten Behauptung muss foo ein Beispiel der NSNumber Klasse sein.

- (Leere) setMyValue: (NSNumber

</syntaxhighlight>

In der obengenannten Behauptung muss foo ein Beispiel der NSNumber Klasse sein, und es muss sich dem aProtocol Protokoll anpassen.

Das dynamische Schreiben kann eine starke Eigenschaft sein. Wenn er Behälterklassen mit statisch getippten Sprachen ohne generics (wie Java vor der Version 5) durchführt, wird der Programmierer gezwungen, eine Behälterklasse für einen allgemeinen Typ des Gegenstands zu schreiben, und dann sich hin und her zwischen dem abstrakten allgemeinen Typ und dem echten Typ zu werfen. Das Gussteil bricht jedoch die Disziplin des statischen Schreibens. Zum Beispiel wird das Stellen in einer ganzen Zahl und eine Schnur vorlesend, einen Laufzeitfehler erzeugen. Dieses Problem wird in, zum Beispiel, Java 5 und C# mit der allgemeinen Programmierung gerichtet, aber dann müssen Behälterklassen im Typ homogen sein. Das braucht mit dem dynamischen Schreiben nicht der Fall zu sein.

Versand

Ziel-C erlaubt das Senden einer Nachricht an einen Gegenstand, der nicht antworten kann. Anstatt der Reaktion oder einfach des Fallens der Nachricht kann ein Gegenstand die Nachricht an einen Gegenstand nachschicken, der antworten kann. Versand kann verwendet werden, um Durchführung von bestimmten Designmustern, wie das Beobachter-Muster oder das Proxymuster zu vereinfachen.

Die Objektive-C Durchlaufzeit gibt ein Paar von Methoden in an

• Versand von Methoden:

- (retval_t) vorwärts: (SEL) sel args: (arglist_t) args;//mit GCC

- (id) vorwärts: (SEL) sel args: (marg_list) args;//mit NeXT / Apfel-Systemen

</syntaxhighlight>

• Handlungsmethoden:

- (retval_t) performv: (SEL) sel args: (arglist_t) args;//mit GCC

- (id) performv: (SEL) sel args: (marg_list) args;//mit NeXT / Apfel-Systemen

</syntaxhighlight>

Ein Gegenstand, der möchte Versand durchführen, muss nur die Versandmethode mit einer neuen Methode überreiten, das Versandverhalten zu definieren. Die Handlungsmethode braucht nicht überritten zu werden, weil diese Methode bloß eine Handlung durchführt, die auf dem Auswählenden und den Argumenten gestützt ist. Bemerken Sie den Typ, der der Typ von Nachrichten im Ziel-C ist.

Zeichen: In OpenStep, Kakao, und GNUstep, dem allgemein verwendeten Fachwerk des Ziels-C, verwendet man die Klasse nicht. Die Methode der Klasse wird verwendet, um Versand zu tun.

Beispiel

Hier ist ein Beispiel eines Programms, das die Grundlagen des Versands demonstriert.

Forwarder.h

1. Import

@interface-Spediteur: Wenden Sie {\ein

Id-Empfänger;//Der Gegenstand wollen wir die Nachricht daran nachschicken.

}\

//Zugriffsberechtigter-Methoden.

- (id) Empfänger;

- (id) setRecipient: (id) _recipient;

@end</syntaxhighlight>

Forwarder.m

1. importieren Sie "Forwarder.h"

@implementation-Spediteur

- (retval_t) vorwärts: (SEL) sel args: (arglist_t) args {\

/ *

* Kontrolle, ob der Empfänger wirklich auf die Nachricht antwortet.

* kann Das oder, kann zum Beispiel, wenn ein Empfänger nicht wünschenswert

sein

* antwortet der Reihe nach auf die Nachricht nicht, sie könnte Versand tun

* selbst.

*/

wenn ([Empfänger respondsToSelector:sel]) {\

geben Sie [Empfänger performv:sel args:args] zurück;

} sonst {\

Rückkehr [selbst Fehler: "Empfänger antwortet"] nicht;

}\}\

- (id) setRecipient: (id) _recipient {\

[Empfänger-Autoausgabe];

Empfänger = [_recipient behält];

kehren Sie selbst zurück;}\

- (id) Empfänger {\

geben Sie Empfänger zurück;

}\@end</syntaxhighlight>

Recipient.h

Import

//Ein einfacher Empfänger-Gegenstand.

@interface-Empfänger: Gegenstand

- (id) hallo;

@end</syntaxhighlight>

Recipient.m

1. importieren Sie "Recipient.h"

@implementation-Empfänger

- (id) hallo {\

printf ("Empfänger sagt hallo! \n");

kehren Sie selbst zurück;}\@end</syntaxhighlight>

main.m

importieren Sie "Forwarder.h"importieren Sie "Recipient.h"

int wichtiger (leerer) {\

Spediteur *forwarder = [Spediteur neu];

Empfänger *recipient = [Empfänger neu];

[Spediteur setRecipient:recipient];//Satz der Empfänger.

/ *

* Bemerken, dass Spediteur auf hallo Nachricht nicht antwortet! Es wird

* nachgeschickt werden. Alle unerkannten Methoden werden zu nachgeschickt

* der Empfänger

* (wenn der Empfänger ihnen, wie geschrieben, im Spediteur antwortet)

*/

[Spediteur hallo];

[Empfänger-Ausgabe];

[Spediteur-Ausgabe];

kehren Sie 0 zurück;

}\</syntaxhighlight>

Referenzen

Wenn kompiliert, mit gcc, die Bearbeiter-Berichte:

$ gcc-x Ziel-c - Wno-Import Forwarder.m Recipient.m main.m-lobjc

main.m: In `der wichtigen' Funktion:

wichtig m:12: Warnung: `Spediteur' antwortet auf `hallo' nicht

$\

Der Bearbeiter meldet das Argument angebracht früher, der auf hallo Nachrichten nicht antwortet. In diesem Umstand ist es sicher, die Warnung zu ignorieren, seitdem Versand durchgeführt wurde. Das Laufen des Programms erzeugt diese Produktion:

$./a.out

Empfänger sagt hallo!

Kategorien

Während des Designs des Ziels-C war eine der Hauptsorgen die Haltbarkeit von großen Codebasen. Die Erfahrung von der strukturierten Programmierwelt hatte gezeigt, dass eine der Hauptweisen, Code zu verbessern, es unten in kleinere Stücke zerbrechen sollte. Ziel-C hat geliehen und hat das Konzept von Kategorien von Plausch-Durchführungen erweitert, um mit diesem Prozess zu helfen.

Eine Kategorie sammelt Methode-Durchführungen in getrennte Dateien. Der Programmierer kann Gruppen von zusammenhängenden Methoden in eine Kategorie legen, um sie lesbarer zu machen. Zum Beispiel konnte man eine "Rechtschreibprüfungs"-Kategorie im Schnur-Gegenstand schaffen, alle Methoden sammelnd, die damit verbunden sind, in einen einzelnen Platz Rechtschreibung zu prüfen.

Außerdem werden die Methoden innerhalb einer Kategorie zu einer Klasse an der Durchlaufzeit hinzugefügt. So erlauben Kategorien dem Programmierer, Methoden zu einer vorhandenen Klasse ohne das Bedürfnis hinzuzufügen, diese Klasse wiederzukompilieren oder sogar Zugang zu seinem Quellcode zu haben. Zum Beispiel, wenn ein System kein Rechtschreibprüfprogramm in seiner Schnur-Durchführung enthält, konnte es hinzugefügt werden, ohne den Schnur-Quellcode zu modifizieren.

Methoden innerhalb von Kategorien werden nicht zu unterscheidend von den Methoden in einer Klasse, wenn das Programm geführt wird. Eine Kategorie hat vollen Zugang zu allen Beispiel-Variablen innerhalb der Klasse einschließlich privater Variablen.

Wenn eine Kategorie eine Methode mit derselben Methode-Unterschrift wie eine vorhandene Methode in einer Klasse erklärt, wird die Methode der Kategorie angenommen. So können Kategorien nicht Methoden zu einer Klasse nur hinzufügen, sondern auch vorhandene Methoden ersetzen. Diese Eigenschaft kann verwendet werden, um Programmfehler in anderen Klassen durch das Neuschreiben ihrer Methoden zu bestechen, oder eine globale Änderung zu einem Verhalten einer Klasse innerhalb eines Programms zu verursachen. Wenn zwei Kategorien Methoden mit demselben Namen haben (um mit der Methode-Unterschrift nicht verwirrt zu sein), ist es unbestimmt, welche Methode der Kategorie angenommen wird.

Andere Sprachen haben versucht, diese Eigenschaft in einer Vielfalt von Wegen hinzuzufügen. TOM hat das Objektive-C System ein Schritt weiter genommen und hat die Hinzufügung von Variablen ebenso berücksichtigt. Andere Sprachen haben orientierte Lösungen des Prototyps statt dessen mit dem bemerkenswertesten Wesen Selbst verwendet.

C# und Visuell Basic.NET Sprachwerkzeug oberflächlich ähnliche Funktionalität in der Form von Erweiterungsmethoden, aber haben diese Zugang zu den privaten Variablen der Klasse nicht. Rubin und mehrere andere dynamische Programmiersprachen kennzeichnen die Technik als "Affe-Flicken".

Logtalk führt ein Konzept von Kategorien durch (als erstklassige Entitäten), der Objektive-C Kategorie-Funktionalität unterordnet (Kategorien von Logtalk können auch als feinkörnige Einheiten der Zusammensetzung verwendet werden, wenn man z.B neue Klassen oder Prototypen definiert; insbesondere eine Kategorie von Logtalk kann durch jede Zahl von Klassen und Prototypen eigentlich importiert werden).

Beispiel-Gebrauch von Kategorien

Dieses Beispiel baut eine Klasse, durch das Definieren zuerst einer grundlegenden Klasse mit nur Zugriffsberechtigter-Methoden durchgeführt und das Hinzufügen von zwei Kategorien auf, und, die die grundlegende Klasse erweitern. Während Kategorien auf die privaten Datenmitglieder der Grundklasse zugreifen können, ist es häufig gute Praxis, um auf diese privaten Datenmitglieder durch die Zugriffsberechtigter-Methoden zuzugreifen, der hilft, Kategorien unabhängiger von der Grundklasse zu halten. Das ist ein typischer Gebrauch von Kategorien - der andere soll Kategorien verwenden, um bestimmte Methoden in der Grundklasse hinzuzufügen oder zu ersetzen (jedoch es wird als gute Praxis nicht betrachtet, um Kategorien für das Unterklasse-Überlaufen, auch bekannt als Affe-Flicken zu verwenden).

Integer.h

Import Ganze

@interface-Zahl: Wenden Sie {\ein

int ganze Zahl;

}\

- (int) ganze Zahl;

- (id) ganze Zahl: (interne Nummer) _integer;

@end</syntaxhighlight>

Integer.m

1. importieren Sie "Integer.h"

Ganze

@implementation-Zahl

- (int) ganze Zahl {\

geben Sie ganze Zahl zurück;

}\

- (id) ganze Zahl: (interne Nummer) _integer {\

ganze Zahl = _integer;

kehren Sie selbst zurück;}\@end</syntaxhighlight>

Arithmetic.h

importieren Sie "Integer.h"Ganze

@interface-Zahl (Arithmetik)

- (id) tragen bei: (Ganze Zahl *) Summand;

- (id) U-Boot: (Ganze Zahl *) Subtrahend;

@end</syntaxhighlight>

Arithmetic.m

1. importieren Sie "Arithmetic.h"

Ganze

@implementation-Zahl (Arithmetik)

- (id) tragen bei: (Ganze Zahl *) Summand {\

Rückkehr [selbst ganze Zahl: [selbst ganze Zahl] + ganze Summand-Zahl;

}\

- (id) U-Boot: (Ganze Zahl *) Subtrahend {\

Rückkehr [selbst ganze Zahl: [selbst ganze Zahl] - ganze Subtrahend-Zahl;

}\@end</syntaxhighlight>

Display.h

importieren Sie "Integer.h"Ganze

@interface-Zahl (Anzeige)

- (id) showstars;

- (id) showint;

@end</syntaxhighlight>

Display.m

1. importieren Sie "Display.h"

Ganze

@implementation-Zahl (Anzeige)

- (id) showstars {\

interne Nummer i, x = [selbst ganze Zahl];

für (ich = 0; ich

main.mimportieren Sie "Integer.h"importieren Sie "Arithmetic.h"importieren Sie "Display.h"int wichtiger (leerer) {\

Ganze Zahl *num1 = [Ganze Zahl neu], *num2 = [Ganze Zahl neu];

interne Nummer x;

printf ("Gehen in eine ganze Zahl ein:");

scanf (" %d", &x);

[num1 integer:x];

[num1 showstars];

printf ("Gehen in eine ganze Zahl ein:"); scanf (" %d", &x);

[num2 integer:x];

[num2 showstars];

[num1 add:num2];

[num1 showint];

kehren Sie 0 zurück;}\</syntaxhighlight>

Referenzen

Kompilation wird zum Beispiel durchgeführt, durch:

gcc-x Ziel-c main.m Integer.m Arithmetic.m Display.m-lobjc

Man kann experimentieren, indem man und Linien weglässt, und in der Kompilation weglassen. Das Programm wird noch laufen. Das bedeutet, dass es zur "Mischung-Und-Match" möglich ist, haben Kategorien nötigenfalls beigetragen; wenn man etwas in einer Kategorie zur Verfügung gestellte Fähigkeit nicht zu haben braucht, kann man nicht sie einfach darin kompilieren.

Das Aufstellen

Ziel-C erlaubt einer Klasse, eine andere Klasse innerhalb eines Programms ganz zu ersetzen. Wie man sagt, "gibt" die Ersetzen-Klasse für die Zielklasse "aus".

Zeichen: Das Klassenaufstellen wurde missbilligt mit Mac OS X v10.5 erklärt, und ist in der 64-Bit-Durchlaufzeit nicht verfügbar.

Für die Versionen, die noch das Aufstellen unterstützen, werden alle an die Zielklasse gesandten Nachrichten stattdessen durch die Aufstellen-Klasse erhalten. Es gibt mehrere Beschränkungen:

• Eine Klasse kann nur für eine seiner direkten oder indirekten Superklassen ausgeben.
• Die Aufstellen-Klasse muss keine neuen Beispiel-Variablen definieren, die von der Zielklasse fehlen (obwohl es definieren oder Methoden überreiten kann).
• Die Zielklasse kann keine Nachrichten vor dem Aufstellen erhalten haben.

Das Aufstellen, ähnlich mit Kategorien, erlaubt globale Zunahme von vorhandenen Klassen. Das Aufstellen von Erlaubnissen zwei Eigenschaften, die von Kategorien fehlen:

• Eine Aufstellen-Klasse kann überrittene Methoden durch den fantastischen nennen, so die Durchführung der Zielklasse vereinigend.
• Eine Aufstellen-Klasse kann in Kategorien definierte Methoden überreiten.

Zum Beispiel,

@interface CustomNSApplication: NSApplication

@end

@implementation CustomNSApplication

- (Leere) setMainMenu: (NSMenu *) Menü {\

//tun Sie etwas mit dem Menü

}\@end

class_poseAs ([Klasse von CustomNSApplication], [NSApplication Klasse]);

</syntaxhighlight>

Das fängt jede Beschwörung von setMainMenu zu NSApplication ab.

#import

In der c Sprache veranlasst die vorkompilieren Direktive immer einen Inhalt einer Datei, in die Quelle an diesem Punkt eingefügt zu werden. Ziel-C hat die gleichwertige Direktive außer jeder Datei wird nur eingeschlossen, sobald pro Kompilationseinheit, das Bedürfnis danach begegnend, Wächter einschließen.

Andere Eigenschaften

Objektive-C's Eigenschaften berücksichtigen häufig flexibel, und häufig leicht, Lösungen der Programmierung von Problemen.

• Das Beauftragen von Methoden zu anderen Gegenständen und entfernter Beschwörung kann mit Kategorien und Nachrichtenversand leicht durchgeführt werden.
• Swizzling des Zeigestocks berücksichtigt Klassen, um sich an der Durchlaufzeit zu ändern. Normalerweise verwendet, um die Fehler zu beseitigen, wo befreite Gegenstände swizzled in Zombie-Gegenstände sind, deren nur Zweck ist, einen Fehler auszugeben, wenn jemand sie nennt. Swizzling wurde auch im Unternehmensgegenstand-Fachwerk verwendet, um Datenbankschulden zu schaffen. Swizzling wird heute durch das Fundament-Fachwerk des Apfels verwendet, um das Schlüsselwert-Beobachten durchzuführen.
• Anordnung, das allgemein genannte Archivieren im Ziel-C, kann durch das Überschreiben gelesen getan werden und Methoden schreiben.

Sprachvarianten

Ziel-C ++

Ziel-C ++ ist ein Vorderende zur GNU-Bearbeiter-Sammlung, die Quelldateien kompilieren kann, die eine Kombination von C ++ und Objektive-C Syntax verwenden. Ziel-C ++ trägt zu C ++ bei das Erweiterungsziel-C trägt zu C bei. Da nichts getan wird, um die Semantik hinter den verschiedenen Spracheigenschaften zu vereinigen, gelten bestimmte Beschränkungen:

• Ein C ++ Klasse kann auf keine Objektive-C Klasse und umgekehrt zurückzuführen sein.
• C ++ kann namespaces nicht innerhalb einer Objektiven-C Behauptung erklärt werden.
• Objektive-C Behauptungen können nur im globalen Spielraum erscheinen, nicht innerhalb eines C ++ namespace
• Objektive-C Klassen können Beispiel-Variablen von C ++ Klassen nicht haben, die keinen Verzug-Konstrukteur haben, oder die eine oder mehr virtuelle Methoden, aber Zeigestöcke zu C ++ haben, können Gegenstände als Beispiel-Variablen ohne Beschränkung verwendet werden (teilen Sie sie mit dem neuen in der-init Methode zu).
• C ++ "durch den Wert" kann Semantik nicht auf Objektive-C Gegenstände angewandt werden, die nur durch Zeigestöcke zugänglich sind.
• Eine Objektive-C Behauptung kann nicht innerhalb eines C ++ Schablone-Behauptung und umgekehrt sein. Jedoch können Typen Objective-C, (z.B, Classname *) als C ++ Schablone-Rahmen verwendet werden.
• Ziel-C und C ++ das Ausnahme-Berühren sind verschieden; die Dressierer von jedem können Ausnahmen des anderen Typs nicht behandeln.
• Sorge muss genommen werden seit dem destructor passt das Benennen der Vereinbarung des Ziels-C und C ++ 's Ausnahme-Laufzeitmodelle nicht zusammen (d. h. ein C ++ destructor wird nicht genannt, wenn eine Objektive-C Ausnahme über den C ++ das Spielraum des Gegenstands herrscht). Die neue 64-Bit-Durchlaufzeit löst das durch das Einführen der Zwischenfunktionsfähigkeit mit C ++ Ausnahmen in diesem Sinn auf.

Objektive-C 2.0

In 2006 Weltentwickler-Konferenz hat Apfel die Ausgabe "Objektiver-C 2.0 bekannt gegeben," unterstützt eine Revision der Objektiven c Sprache, um "moderne Müll-Sammlung, Syntax-Erhöhungen, Zeitverhalten-Verbesserungen, und 64 Bit einzuschließen,". Mac OS X v10.5, veröffentlicht im Oktober 2007, hat einen Objektiven-C 2.0 Bearbeiter eingeschlossen. GCC 4.6 Unterstützungen viele neue Objektive-C Eigenschaften, solcher, wie erklärt und synthetisiert Eigenschaften, punktieren Syntax, schnelle Enumeration, fakultative Protokoll-Methoden, Attribute der Methode/Protokolls/Klasse, Klassenerweiterungen und eine neue GNUnn Objektive-C Laufzeit-API.

Müll-Sammlung

Objektive-C 2.0 stellen einem fakultativen Konservativen, noch generational Müllmann zur Verfügung. Wenn geführt, in der umgekehrt vereinbaren Weise, die Laufzeitumdrehungsbezugszählen-Operationen, die "behalten" und in nein "veröffentlichen". Alle Gegenstände sind der Müll-Sammlung unterworfen, wenn Müll-Sammlung ermöglicht wird. Regelmäßige C Zeigestöcke können mit "__ stark" qualifiziert werden, um auch die zu Grunde liegenden Schreiben-Barriere-Bearbeiter-Abschnitte auszulösen und so an der Müll-Sammlung teilzunehmen. Schwaches Subsystem eines Null-Ing wird auch solch zur Verfügung gestellt, dass Zeigestöcke gekennzeichnet als "__ schwach" auf die Null gesetzt werden, wenn der Gegenstand (oder einfacher, GC Gedächtnis) gesammelt wird. Der Müllmann besteht auf der EIN/AUSGABE-STEUERSYSTEM-Durchführung von Objektiven-C 2.0 nicht. Die Müll-Sammlung in Objektiven-C Läufen auf einem Hintergrundfaden des niedrigen Vorrangs, und kann auf Benutzerereignissen mit der Absicht hinken, die Benutzererfahrung antwortend zu halten.

Eigenschaften

Objektive-C 2.0 führen eine neue Syntax ein, um Beispiel-Variablen als Eigenschaften mit fakultativen Attributen zu erklären, die Generation von Zugriffsberechtigter-Methoden zu konfigurieren. Eigenschaften, sind gewissermaßen, öffentliche Beispiel-Variablen; wenn es eine Beispiel-Variable weil erklärt, versorgt ein Eigentum Außenklassen mit dem Zugang (vielleicht beschränkt, lesen Sie z.B nur) zu diesem Eigentum. Ein Eigentum kann so "read-only-" erklärt werden, und kann mit der Lagerungssemantik solcher versorgt werden, wie "zuteilen", "kopieren" oder "behalten". Standardmäßig werden Eigenschaften atomar betrachtet, der auf ein Schloss hinausläuft, das vielfache Fäden davon abhält, auf sie zur gleichen Zeit zuzugreifen. Ein Eigentum kann als "nichtatomar" erklärt werden, der dieses Schloss entfernt.

@interface-Person: NSObject {\

@public

NSString *name;

@private

int Alter;

}\

@property (Kopie) NSString *name;

@property int (read-Only-)-Alter;

- (id) initWithAge: (int) Alter;

@end</syntaxhighlight>

Eigenschaften werden über das @synthesize Schlüsselwort durchgeführt, das Hauer (und Setter, wenn nicht read-only-) Methoden gemäß der Eigentumsbehauptung erzeugt. Wechselweise müssen der Hauer und die Setter-Methoden ausführlich durchgeführt werden, oder das @dynamic Schlüsselwort kann verwendet werden, um anzuzeigen, dass Zugriffsberechtigter-Methoden durch andere Mittel zur Verfügung gestellt werden.

@implementation-Person

@synthesize-Name;

- (id) initWithAge: (interne Nummer) initAge {\

Alter = initAge;//ZEICHEN: direkte Beispiel-Variable-Anweisung, nicht Eigentumssetter

kehren Sie selbst zurück;}\

- (int) Alter {\

geben Sie Alter zurück;

}\@end</syntaxhighlight>Auf

Eigenschaften kann mit der traditionellen Nachricht vorübergehende Syntax, Punktnotation, oder, im Schlüsselwert-Codieren, namentlich über "valueForKey zugegriffen werden:" / "setValue:forKey:" Methoden.

Person *aPerson =

aPerson.name = "Steve";//ZEICHEN: Punktnotation, synthetisierter Setter des Gebrauches,

//gleichwertig zu [aPerson setName: "Steve"];

NSLog ("Zugang durch die Nachricht (%), punktieren Sie Notation (%),

Eigentumsname (%) und direkter Beispiel-Variable-Zugang (%)",

[APerson-Name], aPerson.name, [aPerson "nennt" valueForKey:@], aPerson-> Name);

</syntaxhighlight>

Um Punktnotation zu verwenden, um Eigentumszugriffsberechtigte innerhalb einer Beispiel-Methode, "selbst" anzurufen, sollte Schlüsselwort verwendet werden:

- (Leere) introduceMyselfWithProperties: (BOOL) useGetter {\

NSLog ("Hallo, mein Name ist %.", (useGetter? self.name: Name));

//ZEICHEN: Hauer gegen den ivar Zugang

}\</syntaxhighlight>

Eine Klasse oder die Eigenschaften des Protokolls können dynamisch introspected sein.

interne Nummer i;

interne Nummer propertyCount = 0;

objc_property_t *propertyList = class_copyPropertyList ([aPerson Klasse], &propertyCount);

für (ich = 0; ich

Nichtzerbrechliche Beispiel-Variablen

Objektive-C 2.0 stellen nichtzerbrechliche Beispiel-Variablen, wo unterstützt, durch die Durchlaufzeit zur Verfügung (d. h. wenn sie 64 Bit Code von Mac OS X sowie der ganze EIN/AUSGABE-STEUERSYSTEM-Code bauen). Unter der modernen Durchlaufzeit wird eine Extraschicht des Umwegs hinzugefügt, um variablen Zugang als Beispiel anzuführen, dem dynamischen linker erlaubend, Beispiel-Lay-Out an der Durchlaufzeit anzupassen. Diese Eigenschaft berücksichtigt zwei wichtige Verbesserungen zum Objektiven-C Code:

• Das beseitigt das zerbrechliche binäre Schnittstelle-Problem - Superklassen können Größen ändern, ohne binäre Vereinbarkeit zu betreffen.
• Das erlaubt Beispiel-Variablen, die die Unterstützung für Eigenschaften zur Verfügung stellen, an der Durchlaufzeit ohne sie synthetisiert zu werden, in der Schnittstelle der Klasse erklärt werden.

Schnelle Enumeration

Anstatt einen NSEnumerator-Gegenstand oder Indizes zu verwenden, um durch eine Sammlung, Objektive-C 2.0 Angebote die schnelle Enumerationssyntax zu wiederholen. In Objektiven-C 2.0 sind die folgenden Schleifen funktionell gleichwertig, aber haben verschiedene Leistungseigenschaften.

//Das Verwenden NSEnumerator

NSEnumerator *enumerator = [thePeople objectEnumerator];

Person *p;

während ((p = [Zähler nextObject])! = Null) {\

NSLog ("ist % %i Jahre alt.", [p Name], [p Alter]);

}\</syntaxhighlight>

//Das Verwenden von Indizes

für (interne Nummer i = 0; ich

//Das Verwenden schneller Enumeration

für (Person *p in thePeople) {\

NSLog ("ist % %i Jahre alt.", [p Name], [p Alter]);}\</syntaxhighlight>

Schnelle Enumeration erzeugt effizienteren Code als Standardenumeration, weil Methode-Anrufe, über Gegenstände aufzuzählen, durch die Zeigestock-Arithmetik das Verwenden des Protokolls von NSFastEnumeration ersetzt werden.

Implikationen für die Kakao-Entwicklung

Alle Objektiven-C Anwendungen haben sich für Mac OS X entwickelt, die von den obengenannten Verbesserungen für Objektive-C 2.0 Gebrauch machen, sind mit allen Betriebssystemen vor 10.5 (Leopard) unvereinbar. Da schnelle Enumeration genau dieselben Dualzahlen wie Standardenumeration nicht erzeugt, wird sein Gebrauch eine Anwendung veranlassen, auf OS X Version 10.4 oder früher zu zertrümmern.

Tragbarer Gegenstand-Bearbeiter

Außer der GCC/NeXT/Apple Durchführung, die mehrere Erweiterungen auf die ursprüngliche Durchführung von Stepstone, ein anderer frei hinzugefügt hat, hat Durchführung des Ziels-C der offenen Quelle gerufen der Tragbare Gegenstand-Bearbeiter besteht auch. Der Satz von durch den Tragbaren Gegenstand-Bearbeiter durchgeführten Erweiterungen unterscheidet sich von der GCC/NeXT/Apple Durchführung; insbesondere es schließt einem Plausch ähnliche Blöcke für das Ziel-C ein, während es an Protokollen und Kategorien, zwei Eigenschaften verwendet umfassend in OpenStep und seinen Ableitungen und Verwandten Mangel hat. Insgesamt vertritt POC eine ältere, vorfolgende Bühne in der Evolution der Sprache, grob conformant zum 1991-Buch von Brad Cox.

Es schließt auch eine Laufzeitbibliothek genannt ObjectPak ein, der auf der ursprünglichen ICPak101 Bibliothek von Cox basiert (der der Reihe nach auf den Plausch 80 Klassenbibliothek zurückzuführen ist), und von OpenStep FoundationKit ganz radikal verschieden ist.

GEOS Ziel-C

Der PC GEOS System hat eine Programmiersprache bekannt als GEOS Ziel-C oder goc verwendet; trotz der Namenähnlichkeit sind die zwei Sprachen nur im gesamten Konzept und dem Gebrauch von Schlüsselwörtern ähnlich, die mit Zeichen vorbefestigt sind.

Klappern

Das Klappern-Bearbeiter-Gefolge, ein Teil des LLVM-Projektes, führt Ziel-C sowie andere Sprachen durch.

Bibliotheksgebrauch

Ziel-C wird häufig heute im Tandem mit einer festen Bibliothek von Standardgegenständen (häufig bekannt als ein "Bastelsatz" oder "Fachwerk"), wie Kakao oder GNUstep verwendet. Diese Bibliotheken kommen häufig mit dem Betriebssystem: Die GNUstep Bibliotheken kommen häufig mit dem gestützten Vertrieb von GNU/Linux, und Kakao kommt mit Mac OS X. Der Programmierer wird nicht gezwungen, Funktionalität von der vorhandenen Grundklasse (NSObject) zu erben. Ziel-C berücksichtigt die Behauptung von neuen Wurzelklassen, die keine vorhandene Funktionalität erben. Ursprünglich, Ziel-C, das basierte Programmierung von Umgebungen normalerweise einer Gegenstand-Klasse als die Grundklasse angeboten hat, von der fast alle anderen Klassen geerbt haben. Mit der Einführung von OpenStep hat NeXT eine neue Grundklasse genannt NSObject geschaffen, der zusätzliche Eigenschaften über den Gegenstand (eine Betonung auf dem Verwenden von Gegenstand-Verweisungen und Verweisung angeboten hat, die statt roher Zeigestöcke, zum Beispiel zählt). Fast alle Klassen in Kakao erben von NSObject.

Nicht nur hat die Umbenennung gedient, um das neue Verzug-Verhalten von Klassen innerhalb der API von OpenStep zu unterscheiden, aber es hat Code erlaubt, der Gegenstand — die ursprüngliche Grundklasse verwendet hat, die auf NeXTSTEP (und, mehr oder weniger, andere Objektive-C Klassenbibliotheken) verwendet ist — um in derselben Durchlaufzeit mit dem Code zu koexistieren, der NSObject (mit einigen Beschränkungen) verwendet hat. Die Einführung des zwei Brief-Präfixes ist auch eine vereinfachte Form von namespaces geworden, an dem Ziel-C Mangel hat. Das Verwenden eines Präfixes, um einen informellen Verpackungsbezeichner zu schaffen, ist ein informeller Codierstandard in der Objektiven-C Gemeinschaft geworden, und geht bis jetzt weiter.

Analyse der Sprache

Objektive-C Durchführungen verwenden ein dünnes Laufzeitsystem, das in C geschrieben ist, der wenig zur Größe der Anwendung hinzufügt. Im Gegensatz, die meisten objektorientierten Systeme zurzeit, dass es verwendete große virtuelle Maschinendurchlaufzeiten geschaffen wurde. Im Ziel-C geschriebene Programme neigen dazu, nicht viel größer zu sein, als die Größe ihres Codes und diese der Bibliotheken (die allgemein in den Softwarevertrieb nicht eingeschlossen zu werden brauchen), im Gegensatz zu Plausch-Systemen, wo ein großer Betrag des Gedächtnisses gerade verwendet wurde, um ein Fenster zu öffnen. Objektive-C Anwendungen neigen dazu, größer zu sein, als ähnlicher C oder C ++ Anwendungen, weil das Objektive-C dynamische Schreiben Methoden nicht erlaubt, abgezogen zu werden, oder inlined. Da der Programmierer solche Freiheit hat zu delegieren, schicken Sie Anrufe nach, bauen Sie Auswählende im Fluge und passieren Sie ihnen zum Laufzeitsystem, der Objektive-C Bearbeiter kann nicht annehmen, dass es sicher ist, unbenutzte Methoden oder zu Reihenanrufen zu entfernen.

Ebenfalls kann die Sprache oben auf vorhandenen C Bearbeitern (in GCC, zuerst als ein Vorverarbeiter, dann als ein Modul) aber nicht als ein neuer Bearbeiter durchgeführt werden. Das erlaubt Ziel-C, die riesige vorhandene Sammlung des C-Codes, der Bibliotheken, der Werkzeuge zu stärken, usw. können Vorhandene C Bibliotheken in Objektive-C Streifbänder gewickelt werden, um eine OO-Style-Schnittstelle zur Verfügung zu stellen. In diesem Aspekt ist es der GObject Sprache von Bibliothek und Vala ähnlich, die in der Entwicklung von GTK Anwendungen weit verwendet werden.

Alle diese praktischen Änderungen haben die Barriere für den Zugang, wahrscheinlich das größte Problem für die weit verbreitete Annahme des Plausches in den 1980er Jahren gesenkt.

Die ersten Versionen des Ziels-C haben Müll-Sammlung nicht unterstützt. Zurzeit war diese Entscheidung eine Sache von etwas Debatte, und viele Menschen haben lange "tote Zeiten" gedacht (als Plausch Sammlung getan hat), das komplette unbrauchbare System zu machen. Einige 3. Parteidurchführungen haben diese Eigenschaft hinzugefügt (am meisten namentlich GNUstep), und Apfel hat es bezüglich Mac OS X v10.5 durchgeführt.

Eine andere allgemeine Kritik besteht darin, dass Ziel-C Sprachunterstützung für namespaces nicht hat. Statt dessen werden Programmierer gezwungen, Präfixe zu ihren Klassennamen hinzuzufügen, die traditionell kürzer als Namespace-Namen und so für Kollisionen anfälliger sind. Bezüglich 2007 werden alle Klassen von Mac OS X und Funktionen in der Kakao-Programmierumgebung mit "NS" vorbefestigt (z.B. NSObject, NSButton), um sie als das Gehören dem Mac OS X oder EIN/AUSGABE-STEUERSYSTEM-Kern zu identifizieren; der "NS" ist auf die Namen der Klassen, wie definiert, während der Entwicklung von NeXTstep zurückzuführen.

Da Ziel-C eine strenge Obermenge von C ist, behandelt es C primitive Typen als erstklassige Gegenstände nicht.

Verschieden von C ++ unterstützt Ziel-C Maschinenbediener nicht, der überlädt. Auch verschieden von C ++ erlaubt Ziel-C einem Gegenstand, nur von einer Klasse direkt zu erben (Mehrfachvererbung verbietend). Jedoch können Kategorien und Protokolle als eine alternative Weise verwendet werden, dieselben Ergebnisse zu erreichen.

Weil Ziel-C das dynamische Laufzeitschreiben verwendet, und weil alle Methode-Anrufe Funktionsanrufe sind (oder, in einigen Fällen, syscalls), können viele allgemeine Leistungsoptimierungen nicht auf Objektive-C Methoden angewandt werden (zum Beispiel: inlining, unveränderliche Fortpflanzung, Zwischenverfahrensoptimierungen und Skalarersatz von Anhäufungen). Das beschränkt die Leistung von Objektiven-C Abstraktionen hinsichtlich ähnlicher Abstraktionen auf Sprachen wie C ++, wo solche Optimierungen möglich sind. Jedoch ist das ein unvermeidlicher Umtausch, weil solche Optimierungen unwirksam durch Kategorien oder andere Objektive-C Laufzeiteigenschaften gemacht würden, die in C ++ unmöglich sind.

Philosophische Unterschiede zwischen Ziel-C und C ++

Das Design und die Durchführung von C ++ und Ziel-C vertreten verschiedene Annäherungen an das Verlängern C.

Zusätzlich zum Stil von C der Verfahrensprogrammierung, C ++ unterstützt direkt bestimmte Formen der objektorientierten Programmierung, allgemeinen Programmierung und metaprogramming. C ++ kommt auch mit einer großen Standardbibliothek, die mehrere Behälterklassen einschließt. Ähnlich Objektiv-C fügt objektorientierte Programmierung, das dynamische Schreiben und Nachdenken zu C hinzu. Ziel-C stellt keine Standardbibliothek, per se, aber in den meisten Plätzen zur Verfügung, wo Ziel-C verwendet wird, wird es mit einer OpenStep ähnlichen Bibliothek wie OPENSTEP, Kakao oder GNUstep verwendet, die Funktionalität zur Verfügung stellen, die C ++ 's Standardbibliothek ähnlich ist.

Ein bemerkenswerter Unterschied ist, dass Ziel-C reflektierende Eigenschaften der Unterstützung der Durchlaufzeit zur Verfügung stellt, wohingegen C ++ nur einen kleinen Betrag der Laufzeitunterstützung zu C hinzufügt. Im Ziel-C kann ein Gegenstand über seine eigenen Eigenschaften zum Beispiel gefragt werden, ob es auf eine bestimmte Nachricht antworten wird. In C ++ ist das ohne den Gebrauch von Außenbibliotheken nicht möglich.

Der Gebrauch des Nachdenkens ist ein Teil der breiteren Unterscheidung zwischen dynamischen Eigenschaften (während Laufzeit) gegen den statischen (Übersetzungszeit) Eigenschaften einer Sprache. Obwohl Ziel-C und C ++ jeder eine Mischung von beiden Eigenschaften verwendet, wird Ziel-C zu Laufzeitentscheidungen entschieden eingestellt, während C ++ zu Übersetzungszeit-Entscheidungen eingestellt wird. Die Spannung zwischen der dynamischen und statischen Programmierung schließt viele der klassischen Umtausche in der Programmierung ein: Dynamische Eigenschaften fügen Flexibilität hinzu, statische Eigenschaften fügen Geschwindigkeit und Datentypprüfung hinzu.

Allgemeine Programmierung und metaprogramming werden durchgeführt und verschieden auf jeder Sprache - im Ziel-C unterstützt es wird durch das dynamische Schreiben und Nachdenken behandelt, wohingegen in C ++ es über Schablonen behandelt wird.

Siehe auch

• Vergleich von Programmiersprachen

Links

• Die Objektive-C 2.0 Programmiersprache, vom Apfel
• GNUstep objektive-C Basis Programmierung des Handbuches
• Ziel-C durch Brad Cox
• Wenden Sie orientierte Programmierung im Ziel-C ein
• Objektive-C häufig gestellte Fragen
• Objektive-C Programmierung: Der große Trottel-Ranch-Führer von Aaron Hillegass, Ausbildung von Pearson
• In der Objektiven-C, 4. Ausgabe von Stephen Kochan, Addison-Wesley programmierend