'>

langage de programmation Objective-C

Objective-C est un langage de programmation orienté objet à usage général qui ajoute messagerie Smalltalk-style pour le langage de programmation C. Il est le principal langage de programmation utilisé par Apple pour les X et iOS systèmes d'exploitation OS et leurs API respectives, le cacao et Cocoa Touch.

Développé à l'origine au début des années 1980, il a été choisi comme la principale langue utilisée par NeXT pour son système d'exploitation NeXTSTEP, dont OS X et iOS sont dérivées. [1] programmes Objective-C génériques qui n'utilisent pas le cacao ou des bibliothèques Touch peuvent également être compilés pour tout système pris en charge par GCC ou Clang.

Histoire

Objective-C a été créé principalement par Brad Cox et Tom amour dans le début des années 1980 lors de leur société Stepstone. [2] Tous deux avaient été mis en place pour Smalltalk tout Programmation du Centre de Technologies d'ITT Corporation en 1981. Les premiers travaux sur Objective-C remonte à autour de ce moment-là. [3] Cox a été intrigué par les problèmes de la vraie réutilisation dans la conception et la programmation logicielle. Il s'est rendu compte qu'une langue comme Smalltalk serait précieuse dans la création d'environnements de développement pour les développeurs de systèmes chez ITT. Cependant, lui et Tom aiment aussi reconnu que la rétrocompatibilité avec C était d'une importance capitale dans les télécommunications le milieu de l'ingénierie d'ITT. [4]

Cox a commencé à écrire un pré-processeur C pour ajouter certaines fonctionnalités de Smalltalk. Il eut bientôt une implémentation fonctionnelle d'une extension orientée objet du langage C, qu'il a appelé "OOPC" pour Object-Oriented pré-compilateur. [5] Love a été embauché par Schlumberger de recherche en 1982 et a eu la possibilité d'acquérir la première copie commerciale de Smalltalk-80, qui a encore influencé le développement de leur invention.

Afin de démontrer que le véritable progrès pourraient être réalisés, Cox a montré que la fabrication de composants de logiciels interchangeables vraiment eu besoin que de quelques changements pratiques aux outils existants. Plus précisément, ils ont dû supporter des objets d'une manière souple, sont livrés avec un ensemble utilisable des bibliothèques, et permettent le code (et toutes les ressources nécessaires par le code) pour être regroupés dans un seul format multi-plateforme.

Amour et Cox finissent par former une nouvelle entreprise, la productivité Products International (PPI), pour commercialiser leur produit, ce qui couplé un compilateur Objective-C avec les bibliothèques de classes. En 1986, Cox a publié la description principale de l'Objective-C dans sa forme originale dans le livre Programmation orientée objet, une approche évolutive. Bien qu'il ait été pris soin de souligner qu'il n'y a plus le problème de la réutilisation de tout le langage Objective-C a souvent trouvé caractéristique lui-même par rapport à option avec d'autres langues.
Vulgarisation par NeXT

Après Steve Jobs a quitté Apple Computer Inc., il a créé la société NeXT. En 1988, NeXT licence Objective-C de StepStone (le nouveau nom du PPI, le propriétaire de l'Objective-C marque) et a étendu le compilateur GCC pour soutenir Objective-C, et développé les bibliothèques du kit AppKit et la Fondation sur laquelle l'utilisateur NeXTstep interface et Interface Builder étaient fondées. Alors que les stations de travail NeXT n'ont pas réussi à faire un grand impact sur le marché, les outils ont été largement salué dans l'industrie. Cela a conduit à côté de déposer la production de matériel et de se concentrer sur les outils logiciels, la vente de NeXTstep (et OpenStep) comme plate-forme pour une programmation personnalisée.

Le travail de prolonger CCG était conduite par Steve Naroff, qui a rejoint NeXT de StepStone. Les changements du compilateur, mais pas les bibliothèques d'exécution, ont été mises à la disposition selon GPL termes de la licence rendant la contribution open source inutilisable pour le grand public. Cela a conduit à d'autres parties en développement comme sous licence open source. Plus tard, Steve Naroff était également principal contributeur à travailler chez Apple pour construire l'Objective-C frontend pour Clang.

Le projet GNU a commencé à travailler sur son application gratuite du logiciel du cacao, du nom de GNUstep, basé sur le standard OpenStep. [6] Dennis Glatting a écrit la première GNU runtime Objective-C en 1992. La GNU runtime Objective-C, qui a été en usage depuis 1993, est celui développé par Kresten Krab Thorup quand il était étudiant à l'université au Danemark. [Citation nécessaire] Thorup a également travaillé chez NeXT 1993-1996. [Citation nécessaire]

Après l'acquisition de NeXT en 1996, Apple Computer utilisé OpenStep dans son nouveau système d'exploitation, Mac OS X. Cela inclus Objective-C et Objective-C basé développeur outil de NeXT, Project Builder (qui avait été étendu et est maintenant appelé Xcode), ainsi comme outil de conception d'interface, Interface Builder. La plupart de l'actuelle API Cocoa d'Apple est basée sur les objets de l'interface d'OpenStep, et est l'environnement le plus important Objective-C étant utilisé pour le développement actif.
Syntaxe

Objective-C est une couche mince sur le dessus de C, et d'ailleurs est un sur-ensemble strict de C, il est possible de compiler un programme C avec un compilateur Objective-C, et d'inclure librement du code C dans une classe Objective-C.

Objective-C tire sa syntaxe objet de Smalltalk. Toute la syntaxe pour les opérations non-orientés objet (y compris les variables primitives, de pré-traitement, des expressions, des déclarations de fonctions, et les appels de fonction) sont identiques à celle de C, tandis que la syntaxe des fonctionnalités orientées objet est une implémentation de Smalltalk- messagerie section.
Messages

Le modèle Objective-C de programmation orientée objet est basée sur la transmission de messages à des instances d'objets. En Objective-C on n'a pas simplement appeler une méthode, on envoie un message. Ce qui est différent du modèle de programmation Simula-style utilisé par C + +. La différence entre ces deux conceptions, c'est dans la façon dont le code référencées par le procédé ou le nom d'un message est exécutée. Dans un langage Simula-modèle, le nom de la méthode est le plus souvent lié à une section de code dans la classe cible par le compilateur. En Smalltalk et Objective-C, la cible d'un message est résolu à l'exécution, avec l'objet de réception lui-même interpréter le message. Une méthode est identifiée par un sélecteur ou SEL - une chaîne se terminant par NUL soit son nom - et résolu à une méthode pointeur C sa mise en œuvre: un IMP [7] Une conséquence de ceci est que le système de transmission de messages n'a pas de type de contrôle. . L'objet auquel le message s'adresse - le récepteur - n'est pas garanti pour répondre à un message, et si elle n'est pas, elle soulève simplement une exception [8].

L'envoi de la méthode de message à l'objet pointé par le pointeur obj exigerait le code suivant en C + +:

obj-> method (argument);

En Objective-C, cela est écrit comme suit:

[Méthode d'obj: argument];

Les deux styles de programmation ont leurs forces et leurs faiblesses. La programmation orientée objet dans le Simula (C + +) de style permet l'héritage multiple et une exécution plus rapide en utilisant la liaison de la compilation chaque fois que possible, mais il ne supporte pas la liaison dynamique par défaut. Elle oblige également tous les moyens d'avoir une mise en œuvre correspondant à moins qu'ils sont abstraits. La programmation Smalltalk style que celui utilisé en Objective-C permet aux messages d'aller inappliquées, avec la méthode a résolu à sa mise à exécution. Par exemple, un message peut être envoyé à une collection d'objets, dont seulement quelques-uns seront appelés à répondre, sans crainte de produire des erreurs d'exécution. Passage de message n'exige pas non plus qu'un objet soit défini au moment de la compilation. Une mise en œuvre est toujours nécessaire pour la méthode à appeler dans l'objet dérivé. (Voir la section typage dynamique ci-dessous pour plus d'avantages de la dynamique (fin) contraignant.)
Interfaces et implémentations

Objective-C nécessite que l'interface et implémentation d'une classe soient dans les blocs de code déclarées séparément. Par convention, les développeurs placent l'interface dans un fichier d'en-tête et la mise en œuvre dans un fichier de code. Les fichiers d'en-tête, normalement suffixe. H, sont similaires aux fichiers d'en-tête C tandis que les fichiers de mise en œuvre (méthode), normalement suffixe. M, peuvent être très similaires aux fichiers code C.
Interface

L'interface d'une classe est généralement définie dans un fichier d'en-tête. Une convention commune est de nommer le fichier d'en-tête après le nom de la classe, par exemple, Ball.h contiendrait l'interface pour le Bal de la classe.

Une déclaration de l'interface prend la forme:

@ Interface nomclasse: superclassname {
 Des variables / / instance
}
+ 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;
@ End

Dans ce qui précède, ainsi que des signes indiquent méthodes de classe, ou des méthodes qui peuvent être appelées sur la classe elle-même (pas sur un exemple), et des signes moins indiquent les méthodes d'instance, qui ne peuvent être appelées sur une instance particulière de la classe. Les méthodes de classe n'ont pas non plus accès aux variables d'instance.

Le code ci-dessus est à peu près équivalente à la suivante interface C + +:

nomclasse de classe: superclassname publique {
 protégé:
 Des variables / / instance

 publique:
 / / Fonctions de classe (statique)
 static void * classMethod1 ();
 statique return_type classMethod2 ();
 statique return_type classMethod3 (param1_type param1_varName);

 / / Instance fonctions (membre)
 return_type instanceMethod1With1Parameter (param1_type param1_varName);
 instanceMethod2With2Parameters return_type (param1_type param1_varName, param2_type param2_varName = par défaut);
};

Notez que instanceMethod2WithParameters: param2_callName: montre l'entrelacement des segments de sélection avec des expressions d'arguments, pour laquelle il n'existe pas d'équivalent direct en C / C + +.

types de retour peuvent être de tout type C standard, un pointeur vers un objet Objective-C générique, un pointeur vers un type d'objet spécifique comme NSArray *, NSImage * ou NSString *, ou un pointeur vers la classe à laquelle appartient la méthode (instancetype). Le type de retour par défaut est le générique Objective-C type id.

les arguments de méthode commencent par un deux-points suivi par le type d'argument attendu entre parenthèses et le nom de l'argument. Dans certains cas (par exemple, lors de l'écriture système API), il est utile d'ajouter un texte descriptif avant chaque paramètre.

- (Void) SetRangeStart: (int) extrémité de départ: (int) end;
- (Void) importDocumentWithName: (NSString *) Nom withSpecifiedPreferences:
(Préférences *) prefs beforePage: (int) insertPage;

La mise en œuvre

L'interface déclare seulement l'interface de classe et non pas les procédés eux-mêmes: le code actuel est écrite dans le fichier de mise en oeuvre. fichiers de mise en œuvre (méthode) ont normalement l'extension de fichier. m, qui signifiait initialement «Messages». [9]

@ Nomclasse de mise en œuvre
+ (Return_type) classmethod
{
 / / Mise en œuvre
}
- (Return_type) InstanceMethod
{
 / / Mise en œuvre
}
@ End

Les méthodes sont écrits en utilisant leurs déclarations d'interface. En comparant Objective-C et C:

- (Int) Méthode: (int) i
{
 return [self racine_carrée: i];
}

fonction int (int i)
{
 retourner racine_carrée (i);
}

La syntaxe permet pseudo-dénomination des arguments.

- (Int) changeColorToRed: (float) vert rouge: (float) bleu vert: (float) bleu;

[MyColor changeColorToRed: 5,0 vert: bleu 2.0: 6.0];

Les représentations internes d'une méthode varient entre différentes implémentations d'Objective-C. Si myColor est de la couleur de la classe, par exemple méthode changeColorToRed: vert: bleu: peut être étiqueté interne _i_Color_changeColorToRed_green_blue. Le i est de se référer à une méthode d'instance, à la classe, puis les noms des méthodes annexées et colons ont changé de soulignement. Comme l'ordre des paramètres est une partie du nom de la méthode, il ne peut pas être modifiée pour s'adapter au style de codage ou une expression comme de véritables paramètres nommés.

Toutefois, les noms internes de la fonction sont rarement utilisées directement. En règle générale, les messages sont convertis en appels de fonction définie dans l'Objective-C bibliothèque d'exécution. Il n'est pas nécessairement connue au moment de la liaison qui méthode sera appelée parce que la classe du récepteur (l'objet a envoyé le message) ne doit pas être connu avant l'exécution.
Instanciation

Une fois une classe Objective-C est écrit, il peut être instanciée. Ceci est fait en première affectation d'une instance non initialisée de la classe (un objet), puis par l'initialiser. Un objet n'est pas entièrement fonctionnel jusqu'à ce que les deux étapes ont été franchies. Ces étapes doivent être accomplies avec une seule ligne de code de sorte qu'il n'y ait jamais un objet alloué qui n'a pas subi l'initialisation (et parce qu'il n'est pas conseillé de garder le résultat intermédiaire depuis-init peut retourner un objet différent de ce qu'il est appelé).

Instanciation avec le défaut, aucun paramètre-initialisation:

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

Instanciation d'une initialisation personnalisée:

MonObjet * o = [[MonObjet alloc] initWithString: myString];

Dans le cas où aucune initialisation personnalisée est effectuée, la «nouvelle» méthode peut souvent être utilisé à la place des messages alloc-init:

MonObjet * o = [MonObjet nouveau];

En outre, certaines classes implémentent initializers méthode de classe. Comme + nouveau, ils combinent + alloc et-init, mais contrairement + nouvelle, ils retournent une instance autoreleased. Certains initializers méthode de classe prennent des paramètres:

MonObjet * o = [MonObjet objet];
MonObjet * o2 = [MonObjet objectWithString: myString];

Le message d'alloc alloue assez de mémoire pour contenir toutes les variables d'instance d'un objet, définit toutes les variables d'instance à des valeurs nulles, et transforme la mémoire dans une instance de la classe; à aucun moment au cours de l'initialisation de la mémoire d'une instance de la superclasse .

Le message d'initialisation effectue la mise en place de l'instance lors de sa création. La méthode init est souvent écrit comme suit:

- (Id) {initialisation
    self = [super init];
    si (auto) {
        / / Effectuer l'initialisation de l'objet ici
    }
    retourner soi-même;
}

Dans l'exemple ci-dessus, notez le type de retour d'id. Ce type est synonyme de "pointeur vers un objet" en Objective-C (voir la section de typage dynamique).

Le modèle d'initialisation est utilisé afin de s'assurer que l'objet est correctement initialisé par sa superclasse avant la méthode init exécute son initialisation. Il effectue les actions suivantes:

    self = [super init]

        Envoie l'instance superclasse un message init et affecte le résultat à soi-même (pointeur vers l'objet courant).

    if (self)

        Vérifie si le pointeur d'objet retourné est valide avant d'effectuer une initialisation.

    retourner auto

        Retourne la valeur de l'auto à l'appelant.

Un pointeur d'objet non valide a la valeur nulle; instructions conditionnelles telles que "si" nul traiter comme un pointeur NULL, si le code d'initialisation ne seront pas exécutées si [super init] est revenu à zéro. S'il ya une erreur dans l'initialisation de la méthode init doit effectuer tout le nettoyage nécessaire, y compris l'envoi d'un message "libération" de soi-même, et revenir nulle pour indiquer que l'initialisation a échoué. Toute vérification de telles erreurs ne doit être effectuée après avoir appelé l'initialisation superclasse pour s'assurer que la destruction de l'objet sera fait correctement.

Si une classe a plus d'une méthode d'initialisation, un seul d'entre eux (la «initialisation désignée») doit suivre ce modèle, d'autres doivent appeler l'initialiseur désigné à la place de l'initialisation superclasse.
Protocoles

Objective-C a été prolongée chez NeXT d'introduire le concept d'héritage multiple de spécification, mais pas mise en œuvre, à travers la mise en place de protocoles. C'est un modèle réalisable soit en tant multiplient abstrait hérité de la classe de base en C + +, ou comme une «interface» (comme en Java et C #). Objective-C permet l'utilisation de protocoles ad hoc appelées protocoles informels et protocoles compilateur forcées appelées protocoles officiels.

Un protocole informel est une liste des méthodes qu'une classe peut choisir de mettre en œuvre. Il est précisé dans la documentation, car elle n'a aucune présence dans la langue. Protocoles informels comprennent souvent des méthodes optionnelles, qui, si elles sont appliquées, peuvent changer le comportement d'une classe. Par exemple, une classe de champ de texte peut avoir un délégué qui met en œuvre un protocole informel avec une méthode facultative pour effectuer l'auto-complétion de texte utilisateur typé. Le champ de texte découvre si le délégué met en œuvre cette méthode (par réflexion) et, si c'est le cas, appelle la méthode du délégué à soutenir la fonction d'auto-complétion.

Un protocole formel est similaire à une interface en Java ou C #. Il s'agit d'une liste de méthodes que toute la classe puisse se prononcer à mettre en œuvre. Versions d'Objective-C 2.0 requis avant qu'une classe doit implémenter toutes les méthodes dans un protocole, il se déclare comme l'adoption, le compilateur émet une erreur si la classe n'implémente pas toutes les méthodes de ses protocoles déclarés. Objective-C 2.0 ajouté le support pour le marquage de certaines méthodes dans un protocole facultatif, et le compilateur ne fera pas appliquer la mise en œuvre de méthodes facultatives.

Une classe doit être déclarée à mettre en oeuvre ce protocole à dire à s'y conformer. C'est discernable à l'exécution. Protocoles officiels ne peuvent pas fournir des implémentations, ils assurent simplement appelants que les classes qui sont conformes au Protocole fournir des implémentations. Dans la bibliothèque NeXT / Apple, les protocoles sont fréquemment utilisés par le système d'objets distribués pour représenter les capacités d'un objet s'exécutant sur un système distant.

La syntaxe

@ Protocol NSLocking
- (Void) verrouiller;
- (Void) déverrouiller;
@ End

indique qu'il n'y a l'idée abstraite de verrouillage. En affirmant que le protocole est mis en œuvre dans la définition de la classe:

@ Interface NSLock: NSObject <NSLocking>
/ / ...
@ End

Les cas de demande de NSLock qu'ils vont fournir une implémentation pour les deux méthodes d'instance.
Typage dynamique

Objective-C, comme Smalltalk, peut utiliser le typage dynamique: un objet peut être envoyé un message qui n'est pas spécifiée dans son interface. Cela peut permettre une plus grande flexibilité, car elle permet à un objet de "capturer" un message et envoyez le message à un autre objet qui peut répondre au message de façon appropriée, ou envoyer également le message à un autre objet. Ce comportement est connu comme le renvoi d'un message ou d'une délégation (voir ci-dessous). Alternativement, un gestionnaire d'erreurs peut être utilisé dans le cas où le message ne peut être transmis. Si un objet ne transmettre un message, y répondre ou de les manipuler d'une erreur, le message est éliminé en silence. Si les messages sont envoyés à zéro (le pointeur d'objet nul), ils seront ignorés silencieusement ou soulèvent une exception générique, en fonction des options de compilation.

Informations de typage statique peut aussi éventuellement être ajouté à des variables. Cette information est ensuite vérifiée au moment de la compilation. Dans les quatre énoncés suivants, tapez les informations de plus en plus spécifique est fourni. Les états sont équivalentes à l'exécution, mais l'information supplémentaire permet au compilateur d'avertir le programmeur si l'argument passé ne correspond pas au type spécifié.

- (Void) setMyValue: (id) foo;

Dans la déclaration ci-dessus, foo peut être de n'importe quelle classe.

- (Void) setMyValue: (id <NSCopying>) foo;

Dans la déclaration ci-dessus, foo peut être une instance de n'importe quelle classe qui est conforme au protocole NSCopying.

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

Dans la déclaration ci-dessus, foo doit être une instance de la classe NSNumber.

- (Void) setMyValue: (NSNumber <NSCopying> *) foo;

Dans la déclaration ci-dessus, foo doit être une instance de la classe NSNumber, et il doit être conforme au protocole NSCopying.
Renvoi

Objective-C permet l'envoi d'un message à un objet qui ne peut pas répondre. Plutôt que de répondre ou tout simplement laisser tomber le message, un objet peut transférer le message à un objet qui peut répondre. Forwarding peut être utilisé pour simplifier la mise en œuvre de certains modèles de conception, tels que le modèle d'observateur ou le modèle proxy.

Le runtime Objective-C spécifie une paire de méthodes dans l'objet

    Les méthodes d'acheminement:

- (Retval_t) vers l'avant: (SEL) sel args: (arglist_t) args / / avec GCC
- (Id) en avant: (SEL) sel args: (marg_list) args / / avec les systèmes NeXT / Apple a

    méthodes d'action:

- (Retval_t) performv: (SEL) sel args: (arglist_t) args / / avec GCC
- (Id) performv: (SEL) sel args: (marg_list) args / / avec les systèmes NeXT / Apple a

Un objet souhaitant mettre en œuvre le transfert n'a besoin que de remplacer la méthode d'acheminement avec une nouvelle méthode pour définir le comportement de transmission. La méthode d'action performv :: n'ont pas besoin d'être remplacée, car cette méthode effectue simplement une action fondée sur le sélecteur et arguments. Notez le type SEL, qui est le type de messages en Objective-C.

Remarque: dans OpenStep, le cacao et GNUstep, les cadres couramment utilisés Objective-C, on n'utilise pas la classe Object. Le - (void) forwardInvocation: (NSInvocation *) Méthode anInvocation de la classe NSObject est utilisé pour faire le transfert.
Exemple

Voici un exemple d'un programme qui montre les rudiments de la transmission.

Forwarder.h

# Import <objc/Object.h>

@ Interface Porteur: Object {
 Identifiant destinataire; / / L'objet que nous voulons transmettre le message.
}

/ / Méthodes d'accès.
- (Id) destinataire;
- (Id) setRecipient: (id) _recipient;

@ End

Forwarder.m

# Import "Forwarder.h"

@ Porteur de mise en œuvre

- (Retval_t) vers l'avant: (SEL) sel args: (arglist_t) args {
 / *
 * Vérifiez si le destinataire répond réellement au message.
 * Cela peut ou peut ne pas être souhaitable, par exemple, si un bénéficiaire
 * À son tour, ne répond pas au message, il pourrait faire le transfert
 Lui-même *.
 * /
 if ([destinataire respondsToSelector: SEL]) {
 retour [destinataire performv: sel args: args];
 } Else {
 return [self erreur: «bénéficiaire ne répond pas"];
 }
}

- (Id) setRecipient: (id) {_recipient
 [Destinataire autorelease];
 recipient = [_recipient retain];
 retourner soi-même;
}

- (Id) {destinataire
 retourner bénéficiaire;
}
@ End

Recipient.h

# Import <objc/Object.h>

/ / Un objet destinataire simple.
@ Interface destinataire: Objet
- (Id) bonjour;
@ End

Recipient.m

# Import "Recipient.h"

@ Implementation bénéficiaire

- (Id) {bonjour
 printf ("bénéficiaire dit bonjour \ n");

 retourner soi-même;
}

@ End

main.m

# Import "Forwarder.h"
# Import "Recipient.h"

int main (void) {
 Porteur * transitaire = [Porteur nouveau];
 Destinataire * = [Destinataire nouveau];

 [SetRecipient transitaire: bénéficiaire]; / / Définit le destinataire.
 / *
 * Respectez forwarder ne répond pas à un message bonjour! Il sera
 * Être transmis. Toutes les méthodes non reconnus seront transmises au
 * Le destinataire
 * (Si le destinataire répond, comme écrit dans le Porteur)
 * /
 [Transitaire bonjour];

 [Destinataire de presse];
 [Communiqué de transitaire];

 retour 0;
}

Remarques

Lors de la compilation avec gcc, les rapports de compilation:

$ Gcc-x objective-c-Wno-import Forwarder.m Recipient.m main.m-lobjc
main.m: In function `main ':
main.m: 12: avertissement: `Porteur» ne répond pas à `bonjour '
$

Le compilateur signale la remarque faite plus tôt, Porteur ne répond pas aux messages Bonjour. Dans ce cas, il est sûr d'ignorer l'avertissement depuis le renvoi a été mis en œuvre. L'exécution du programme produit la sortie suivante:

$. / A.out
Bénéficiaire dit bonjour!

Catégories

Lors de la conception de l'Objective-C, l'une des principales préoccupations était la maintenabilité de grandes bases de code. L'expérience du monde de la programmation structurée avait montré que l'un des principaux moyens d'améliorer le code était de le décomposer en petits morceaux. Objective-C emprunté et a étendu la notion de catégories d'implémentations de Smalltalk pour aider à ce processus [10].

En outre, les modes d'une même catégorie sont ajoutés à une classe à l'exécution. Ainsi, les catégories permettent au programmeur d'ajouter des méthodes à une classe existante sans avoir besoin de recompiler cette classe ou même avoir accès à son code source. Par exemple, si un système ne contient pas de correcteur orthographique dans la mise en œuvre de la chaîne, il pourrait être ajouté sans modifier le code source de la chaîne.

Méthodes au sein des catégories deviennent indiscernables des méthodes dans une classe quand le programme est exécuté. Une catégorie dispose d'un accès complet à toutes les variables de l'instance au sein de la classe, y compris les variables privées.

Si une catégorie déclare une méthode avec la même signature de méthode comme une méthode existante dans une classe, la méthode de la catégorie est adopté. Ainsi catégories peuvent non seulement ajouter des méthodes à une classe, mais aussi remplacer les méthodes existantes. Cette fonction peut être utilisée pour corriger des bugs dans les autres classes en réécrivant leurs méthodes, ou pour provoquer un changement global de comportement d'une classe à l'intérieur d'un programme. Si deux catégories ont des méthodes avec le même nom (à ne pas confondre avec la signature de méthode), il est indéfini qui la méthode de catégorie est adopté.

Autres langues ont tenté d'ajouter cette fonctionnalité dans une variété de façons. TOM a pris le système Objective-C plus loin et a permis l'ajout de variables aussi bien. Autres langues ont utilisé des solutions axées sur des prototypes de la place, avec le plus notable étant auto.

Le # langages C et Visual Basic.NET implémenter des fonctionnalités superficiellement similaire à la forme de méthodes d'extension, mais ceux-ci n'ont pas accès aux variables privées de la classe. [11] Ruby et plusieurs autres langages de programmation dynamiques se référer à la technique de "singe patching ".

Logtalk met en œuvre un concept de catégories (comme entités de première classe) qui englobe la fonctionnalité des catégories Objective-C (catégories Logtalk peuvent également être utilisés comme unités fine de la composition lors de la définition par exemple de nouvelles classes ou de prototypes, en particulier, une catégorie Logtalk peut être pratiquement importée par un certain nombre de classes et de prototypes).
Exemple d'utilisation de catégories

Cet exemple construit une classe entière, en définissant d'abord une classe de base avec seulement les méthodes d'accès mis en œuvre, et en ajoutant deux catégories, le calcul et d'affichage, qui étendent la classe de base. Bien que les catégories peuvent accéder aux membres de données privés de la classe de base de, il est souvent bonne pratique pour accéder à ces données membres privées à travers les méthodes d'accès, ce qui permet de garder catégories plus indépendante de la classe de base. Il s'agit d'une utilisation typique de catégories, l'autre est d'utiliser les catégories d'ajouter ou de remplacer certaines méthodes dans la classe de base (mais il n'est pas considéré comme une bonne pratique d'utiliser les catégories de sous-classe impérieuses, également connu sous le nom singe patch). Par convention, contenant des fichiers de catégories qui s'étendent classes de base prendront le nom BaseClass + ExtensionClass.h.

Integer.h

# Import <objc/Object.h>

@ Interface Entier: Object {
 int entier;
}

- (Int) entier;
- (Id) entier: (int) _integer;
@ End

Integer.m

# Import "Integer.h"

@ Implementation Entier
- (Int) {entier
 retourner entier;
}

- (Id) entier: (int) {_integer
 Integer = _integer;

 retourner soi-même;
}
@ End

Integer + Arithmetic.h

# Import "Integer.h"

@ Interface Integer (arithmétique)
- (Id) ajouter: (Integer *) addend;
- (Id) sous: (Integer *) diminuteur;
@ End

Integer + Arithmetic.m

# Import "Integer + Arithmetic.h"

@ Implementation Integer (arithmétique)
- (Id) ajouter: (Integer *) addend {
 return [self entier: [self entier] + [addend entier]];
}

- (Id) sous: (Integer *) diminuteur {
 return [self entier: [self entier] - [diminuteur entier]];
}
@ End

Integer + display.h

# Import "Integer.h"

@ Interface Integer (Display)
- (Id) showstars;
- (Id) showint;
@ End

Integer + Display.m

# Import "Integer + display.h"

@ Implementation Integer (Display)
- (Id) {showstars
 int i, x = [self entier];
 for (i = 0; i <x; i + +) {
 printf ("*");
 }
 printf ("\ n");

 retourner soi-même;
}

- (Id) {showint
 printf ("% d \ n", [self entier]);

 retourner soi-même;
}
@ End

main.m

# Import "Integer.h"
# Import "Integer + Arithmetic.h"
# Import "Integer + display.h"

int main (void) {
 Integer * num1 = [Integer nouveau], * num2 = [Integer nouveau];
 int x;

 printf ("Entrez un entier:");
 scanf ("% d", & x);

 [Num1 entier: x];
 [Num1 showstars];

 printf ("Entrez un entier:");
 scanf ("% d", & x);

 [Num2 entier: x];
 [Num2 showstars];

 [Num1 ajouter: num2];
 [Num1 showint];

 retour 0;
}

Remarques

La compilation est effectuée, par exemple, par:

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

On peut expérimenter en omettant le # import "Arithmetic.h» et [num1 ajouter: num2] lignes et omettre Arithmetic.m dans la compilation. Le programme continue à fonctionner. Cela signifie qu'il est possible de «mix-and-match», a ajouté catégories si nécessaire, si l'on n'a pas besoin d'avoir une certaine capacité prévue dans une catégorie, on peut tout simplement pas le compiler po
Posant

Objective-C permet une classe à remplacer totalement une autre classe au sein d'un programme. La classe remplaçant est dit "pose comme« la classe cible.

Note: Classe posant a été déclarée obsolète avec Mac OS X 10.5, et est disponible dans le runtime 64 bits.

Pour les versions en soutenant pose, tous les messages envoyés à la classe cible sont plutôt reçus par la classe pose. Il ya plusieurs restrictions:

    Une classe peut poser seulement comme l'un de ses super-classes directes ou indirectes.
    La classe pose ne doit pas définir de nouvelles variables d'instance qui sont absents de la classe cible (bien qu'il peut définir ou redéfinir les méthodes).
    La classe cible peut ne pas avoir reçu de messages avant la pose.

Posant, même avec des catégories, permet une augmentation globale des classes existantes. Posant permis deux caractéristiques absentes des catégories:

    Une classe posant peut appeler des méthodes redéfinies à travers superbe, intégrant ainsi la mise en œuvre de la classe cible.
    Une classe posant se substituer aux méthodes définies dans les catégories.

Par exemple,

@ Interface CustomNSApplication: NSApplication
@ End

@ CustomNSApplication de mise en œuvre
- (Void) setMainMenu: (NSMenu *) menu {
 / / Faire quelque chose avec le menu
}
@ End

class_poseAs ([classe CustomNSApplication], [classe NSApplication]);

Cette intercepte chaque invocation de setMainMenu à NSApplication.
# Import

Dans le langage C, la directive # include pré-compilation provoque toujours le contenu d'un fichier pour être inséré dans la source à cet endroit. Objective-C a la directive # import équivalent, sauf que chaque fichier est inclus seulement une fois par unité de compilation, éliminant la nécessité d'inclure des gardes.
Autres caractéristiques

Les caractéristiques d'Objective-C permettent souvent de solutions flexibles et souvent facile, pour des questions de programmation.

    Déléguer des méthodes à d'autres objets et l'invocation à distance peut être facilement implémentée en utilisant les catégories et le transfert des messages.
    Swizzling du pointeur isa permet aux classes de changer à l'exécution. Généralement utilisé pour le débogage où les objets sont libérés swizzled en objets de zombies dont le seul but est de signaler une erreur lorsque quelqu'un les appelle. Swizzling a également été utilisé dans le Cadre d'entreprise des objets pour créer des défauts de base de données. Swizzling est utilisé aujourd'hui par le Cadre principal d'Apple pour mettre en œuvre des valeurs-clés d'observation.

variantes linguistiques
Objective-C + +

Objective-C + + est une variante de la langue acceptée par le front-end de la collection de compilateur GNU et Clang, qui permet de compiler les fichiers sources qui utilisent une combinaison de C + + et la syntaxe Objective-C. Objective-C + + ajoute à C + + les extensions que Objective-C ajoute à C. Comme rien n'est fait pour unifier la sémantique derrière les diverses fonctionnalités de langage, certaines restrictions s'appliquent:

    Une classe C + + ne peut pas dériver d'une classe Objective-C et vice versa.
    C + + espaces de noms ne peuvent pas être déclarées dans une déclaration Objective-C.
    Déclarations Objective-C ne peuvent figurer que dans le contexte global, et non pas à l'intérieur d'un espace de nommage C + +
    Classes Objective-C ne peuvent pas avoir les variables d'instance de C + + classes qui n'ont pas un constructeur par défaut ou dont un ou plusieurs des méthodes virtuelles, mais des pointeurs vers des objets C + + peuvent être utilisés comme variables d'instance sans restriction (les affecter à nouveau dans la méthode-init ).
    C + + "par valeur" sémantique ne peuvent pas être appliquées aux objets Objective-C, qui ne sont accessibles que par le biais des pointeurs.
    Une déclaration Objective-C ne peut pas être dans un C + + déclaration de modèle et vice versa. Cependant, les types Objective-C, (par exemple, Classname *) peuvent être utilisés comme paramètres C + + template.
    Objective-C et en C + + gestion d'exception est distincte, et les manipulateurs de chacun ne peut pas gérer des exceptions de l'autre type. Ce risque est atténué en runtimes dernières comme des exceptions Objective-C sont soit remplacés par des exceptions C + + runtime complètement (Apple), ou en partie lorsque Objective-C + + bibliothèque est lié (GNUstep libobjc2).
    Des précautions doivent être prises depuis le destructeur des conventions d'appel d'Objective-C et C + + 's modèles d'exécution exception ne correspondent pas (par exemple, un C + + destructor ne sera pas appelée quand une Objective-C pour sortir d'exception le C + champ d'application de + objet). Le nouveau 64-bit runtime résout ce par l'introduction de l'interopérabilité avec les exceptions C + + dans ce sens [12].

Objective-C 2.0

Au Mondial 2006 Conférence des développeurs, Apple a annoncé la sortie de "Objective-C 2.0," une révision de l'Objective-C langue d'inclure "garbage collection moderne, les améliorations de la syntaxe [13], l'amélioration des performances d'exécution, [14] et 64 - support de l'outil ". Mac OS X v10.5, sorti en Octobre 2007, comprenait un objectif compilateur C 2.0. GCC 4.6 prend en charge de nombreuses nouvelles fonctionnalités en Objective-C, telles que déclarées et les propriétés de synthèse, syntaxe à point énumération rapide, les méthodes de Protocole facultatif, les attributs méthode / protocole / de classe, les extensions de classe et un nouveau Objective-C runtime API GNUnn. [15]
Collecte des ordures ménagères

Objective-C 2.0 a fourni un conservateur, ordures encore générationnelle collecteur en option. Lorsqu'il est exécuté en mode rétro-compatible, l'exécution s'est opérations de comptage de référence tels que "conserver" et "libération" dans aucun d'habitation. Tous les objets ont été soumis à la collecte des ordures lorsque la collecte des ordures a été activée. Pointeurs C réguliers pourraient être qualifiées de «__strong" pour déclencher également des interceptions de compilation écriture barrière sous-jacents et donc participer à la collecte des ordures. [16] Un zéro-ment sous-système faible a également été prévu de sorte que les pointeurs marqués comme "__weak" sont mis à zéro lorsque l'objet (ou, plus simplement, GC mémoire) est collectée. Le garbage collector n'existait pas sur l'application iOS de l'Objective-C 2.0. [17] Collecte des ordures ménagères en Objective-C a couru sur un thread d'arrière-plan à faible priorité, et peut s'arrêter sur les événements de l'utilisateur, avec l'intention de garder l'expérience utilisateur réactive [18].

Collecte des ordures ménagères a été désapprouvée dans OS X v10.8 en faveur de comptage automatique de référence (ARC) et devrait être supprimée dans une future version de Mac OS X. [19]
Propriétés

Objective-C 2.0 introduit une nouvelle syntaxe pour déclarer des variables d'instance en tant que propriétés, avec des attributs facultatifs pour configurer la génération de méthodes d'accès. Les propriétés sont, en un sens, les variables d'instance publiques, c'est-à déclarer une variable d'instance comme une propriété fournit des classes externes avec accès (éventuellement limitée, par exemple en lecture seule) pour cette propriété. Une propriété peut être déclaré comme "lecture seule", et peut être fourni avec la sémantique de stockage tels que "céder", "copie" ou "conserver". Par défaut, les propriétés sont considérées atomique, ce qui entraîne un verrouillage empêchant plusieurs threads d'y accéder en même temps. Une propriété peut être déclaré comme "non atomique", qui supprime cette serrure.

@ Interface de personne: NSObject {
 @ Publique
 NSString * name;
 @ Private
 int age;
}

@ Property (copie) NSString * name;
@ Property (en lecture seule) int age;

- (Id) initWithAge: (int) âge;
@ End

Les propriétés sont mises en œuvre au moyen de la clé de synthétiser @, ce qui génère getter (et setter, si elle n'est pas en lecture seule) des méthodes selon la déclaration de propriété. Alternativement, les méthodes getter et setter doivent être mises en œuvre de façon explicite, ou le mot-clé dynamique @ peuvent être utilisés pour indiquer que des méthodes d'accès seront fournis par d'autres moyens. Lorsque compilé avec fracas 3.1 ou supérieur, toutes les propriétés qui ne sont pas explicitement déclarées avec @ dynamique, marqué en lecture seule ou avoir terminé getter utilisateur en œuvre et setter sera automatiquement implicitement @ synthesize'd.

@ Personne de mise en œuvre
@ Synthétiser nom;

- (Id) initWithAge: (int) {initAge
 self = [super init];
 si (auto) {
 age = initAge; / / NOTE: affectation directe de variable d'instance, pas setter de propriété
 }
 retourner soi-même;
}

- (Int) {âge
 retourner âge;
}
@ End

Les propriétés peuvent être accessibles en utilisant le traditionnel message en passant la syntaxe, la notation par points ou, dans Key-value coding, par nom via le "valueForKey:" / "setValue: forKey:« méthodes.

Personne * aperson = [[alloc de personne] initWithAge: 53];
aPerson.name = @ "Steve"; / / NOTE: notation par point, utilise setter synthétisé,
 / / Équivalent à [aperson setName: @ "Steve"];
NSLog (@ "Accès par message (% @), la notation par points (% @),
nom de la propriété (% @) et accès direct à la variable d'instance (% @) ",
 [Nom aperson], aPerson.name, [aperson valueForKey: @ "nom"], aperson-> nom);

Pour utiliser la notation à point pour invoquer accesseurs de propriété au sein d'une méthode d'instance, le mot «moi» doit être utilisé:

- (Void) introduceMyselfWithProperties: (bool) {useGetter
 NSLog (@ "Salut, je m'appelle% @.", (UseGetter self.name: nom));
/ / NOTE: getter vs accès Ivar
}

Une classe ou les propriétés de protocole peut être introspectés dynamiquement.

int i;
int propertyCount = 0;
objc_property_t * propertyList = class_copyPropertyList ([Classe aperson], et propertyCount);

for (i = 0; i <propertyCount; i + +) {
 objc_property_t * thisproperty = propertyList + i;
 const char * propertyName = property_getName (* thisproperty);
 NSLog (@ "personne possède une propriété: '% s'", propertyName);
}

Variables d'instance non fragiles

Objective-C 2.0 fournit des variables d'instance non fragiles lorsque pris en charge par l'environnement d'exécution (ie lors de la construction 64-bit Mac OS X code ainsi que tous les codes iOS). Dans le cadre du runtime moderne, une couche supplémentaire d'adressage indirect est ajouté à l'instance accès aux variables, permettant à l'éditeur de liens dynamiques pour régler la disposition de l'instance en cours d'exécution. Cette fonctionnalité permet deux améliorations importantes à Objective-C code suivant:

    Ceci élimine l'interface binaire fragile de problèmes superclasses peuvent modifier la taille sans affecter la compatibilité binaire.
    Cela permet aux variables d'instance qui fournit le support pour les propriétés à synthétiser à l'exécution sans qu'elles soient déclarées dans l'interface de la classe.

Énumération rapide

Au lieu d'utiliser un objet NSEnumerator ou indices pour parcourir une collection, Objective-C 2.0 offre la syntaxe d'énumération rapide. En Objective-C 2.0, les boucles suivantes sont fonctionnellement équivalents, mais ont des caractéristiques de performance.

/ / Utilisation NSEnumerator
NSEnumerator * recenseur = [objectEnumerator de thePeople];
Personne * p;

while ((p = [recenseur nextObject])! = nil) {
 NSLog (@ "% @% i ans.", [Nom p] [p age]);
}

/ / Utilisation des index
for (int i = 0; i <[thePeople count]; i + +) {
 Personne * p = [objectAtIndex de thePeople: i];
 NSLog (@ "% @% i ans.", [Nom p] [p age]);
}

/ / Utilisation de l'énumération rapide
pour (personne * p dans thePeople) {
 NSLog (@ "% @% i ans.", [Nom p] [p age]);
}

Dénombrement rapide génère un code plus efficace que l'énumération standard car méthode appelle pour énumérer sur des objets sont remplacés par un pointeur arithmétique en utilisant le protocole de NSFastEnumeration.

Implications pour le développement Cocoa
Toutes les applications Objective-C développé pour Mac OS X qui font usage de ces améliorations pour Objective-C 2.0 ne sont pas compatibles avec tous les systèmes d'exploitation avant 10.5 (Leopard). Depuis énumération rapide ne génère pas exactement les mêmes fichiers binaires que l'énumération standard, son utilisation peut provoquer l'application de s'écraser sur OS X version 10.4 ou une version antérieure.
Blocks
Article détaillé: Blocks (extension du langage C)

Blocks est une extension non standard pour Objective-C (ainsi que C et C + +) qui utilise une syntaxe particulière pour créer des fermetures. Les blocs ne sont pris en charge par Mac OS X 10.6 "Snow Leopard" ou version ultérieure et iOS 4 ou version ultérieure, ainsi que GNUstep avec libobjc2 1.7 et la compilation avec fracas 3.1 ou une version ultérieure. [21]

# Include <stdio.h>
# Include <Block.h>
typedef int (^ IntBlock) ();

IntBlock MakeCounter (int start, int minimum) {
        __block int i = marche;

        retourner Block_copy (^ {
                int ret = i;
                i + = augmentation;
                RET;
        });

}

int main (void) {
        IntBlock mycounter = MakeCounter (5, 2);
        printf ("Premier appel:% d \ n", mycounter ());
        printf ("Deuxième appel:% d \ n", mycounter ());
        printf ("Troisième appel:% d \ n", mycounter ());

        / * Car il a été copié, il doit également être publié * /
        Block_release (mycounter);

        retour 0;
}
/ * Sortie:
        Premier appel: 5
        Deuxième appel: 7
        Troisième appel: 9
* /

Moderne Objective-C
Automatique de comptage de références
Article détaillé: comptage automatique de référence

Automatique de comptage de références (ARC) est une fonction de compilation qui élimine la nécessité pour les programmeurs de gérer manuellement conserver chefs d'accusation à l'aide de retenir et relâchez. [22] Contrairement à la collecte des ordures, ARC élimine la surcharge d'un processus séparé de gestion conserver chefs d'accusation.
Littéraux

NeXT et runtimes Obj-C d'Apple ont longtemps fourni un moyen de court-forme pour créer de nouvelles chaînes, en utilisant la syntaxe littérale @ «une nouvelle chaîne". L'utilisation de ce format enregistre le programmeur d'avoir à utiliser le plus initWithString ou des méthodes similaires lorsque vous effectuez certaines opérations.

Lors de l'utilisation d'Apple LLVM compilateur 4.0 ou version ultérieure, des tableaux, des dictionnaires, et des chiffres (NSArray, NSDictionary, les classes NSNumber) peuvent également être créés en utilisant la syntaxe littérale au lieu de méthodes. [23] syntaxe littérale utilise le symbole @ combiné avec [], {} , (), pour créer des classes mentionnées ci-dessus, respectivement [24].

Exemple sans littéraux:

NSArray * myArray = [NSArray arrayWithObjects: Object1, Object2, Object3, nil];
NSDictionary * myDictionary1 = [NSDictionary dictionaryWithObject: someObject forKey: @ "touche"];
NSDictionary * myDictionary2 = [dictionaryWithObjectsAndKeys NSDictionary: Object1, key1, Object2, key2, zéro];
NSNumber * myNumber = [NSNumber numberWithInt: myInt];

Exemple avec littéraux:

NSArray * myArray = @ [object1, object2, object3];
NSDictionary * myDictionary1 = @ {@ «clé»: someObject};
NSDictionary * myDictionary2 = @ {key1: object1, key2: object2};
NSNumber * myNumber = @ (myInt);

Subscripting

Lors de l'utilisation d'Apple LLVM compilateur 4.0 ou version ultérieure, les tableaux et les dictionnaires (NSArray et les classes NSDictionary) peuvent être manipulés à l'aide subscripting [23]. Subscripting peut être utilisé pour récupérer les valeurs d'index (array) ou les touches (dictionnaire), et avec les objets modifiables, peut également être utilisée pour fixer des objets à des indices ou des clés. Dans le code, subscripting est représenté en utilisant des crochets []. [24]

Exemple sans subscripting:

id = object1 [someArray objectAtIndex: 0];
id = object2 [someDictionary objectForKey: @ "touche"];
[SomeMutableArray replaceObjectAtIndex: 0 withObject: object3];
[SomeMutableDictionary setObject: objet4 forKey: @ "touche"];

Exemple avec subscripting:

id = object1 someArray [0];
id = object2 someDictionary [@ "touche"];
someMutableArray [0] = object3;
someMutableDictionary [@ "touche"] = objet4;

Compiler Portable Object

Outre la mise en œuvre GCC / NeXT / Apple, qui a ajouté plusieurs extensions à la mise en œuvre de Stepstone original, un autre gratuit, application Objective-C open-source appelé le compilateur Portable Object [25] existe aussi. L'ensemble des extensions mises en œuvre par le compilateur Portable Object diffère de la mise en œuvre GCC / NeXT / Apple a, en particulier, il inclut les blocs Smalltalk-comme pour Objective-C, alors qu'il manque des protocoles et des catégories, deux caractéristiques largement utilisés dans OpenStep et ses dérivés et des parents. Dans l'ensemble, POC représente une étape plus ancienne, pré-NeXT dans l'évolution de la langue, à peu près conforme à la livre de Brad Cox 1991.

Il comprend également une bibliothèque d'exécution appelé ObjectPak, qui est basé sur la bibliothèque ICPak101 original de Cox (qui à son tour dérive de la bibliothèque de classes Smalltalk-80), et est assez radicalement différente de la FoundationKit OpenStep.
GEOS Objective-C

Le système GEOS PC utilisé un langage de programmation appelé GEOS Objective-C ou GC, [26] en dépit de la similitude de nom, les deux langues sont similaires que dans le concept global et l'utilisation de mots-clés précédés d'un signe @.
Clang

La suite du compilateur Clang, qui fait partie du projet LLVM, met en œuvre Objective-C ainsi que d'autres langues.
utilisation de la bibliothèque

Objective-C est aujourd'hui souvent utilisé en tandem avec une bibliothèque fixe d'objets standards (souvent connu comme un "kit" ou "cadre"), comme le cacao, GNUstep ou ObjFW. Ces bibliothèques sont souvent livrées avec le système d'exploitation: les bibliothèques GNUstep viennent souvent avec des distributions et de cacao à base de GNU / Linux est livré avec OS X. Le programmeur n'est pas obligé d'hériter de la fonctionnalité de la classe de base existante (NSObject / ofObject). Objective-C permet la déclaration de nouvelles classes racines qui n'héritent pas de toute les fonctionnalités existantes. A l'origine, Objective-C environnements de programmation à base offerts généralement une classe d'objet comme la classe de base à partir de laquelle presque toutes les autres classes héritées. Avec l'introduction de OpenStep, NeXT a créé une nouvelle classe de base nommée NSObject, qui offrait des fonctionnalités supplémentaires par rapport à l'objet (l'accent étant mis sur l'utilisation de références d'objet et le comptage de références au lieu de pointeurs premières, par exemple). Presque toutes les classes Cocoa héritent de NSObject.

Non seulement le changement de nom ne servent à différencier le nouveau comportement par défaut des classes au sein de l'API OpenStep, mais il permettait à du code qui utilise l'objet, la classe de base d'origine utilisé sur NeXTSTEP (et, plus ou moins, d'autres bibliothèques de classes Objective-C) à co-exister dans le même runtime avec le code qui permet NSObject (avec certaines restrictions). L'introduction du préfixe de deux lettres est également devenu une forme simpliste d'espaces de noms, qui Objective-C n'a pas. L'utilisation d'un préfixe pour créer un identificateur d'emballage informel est devenu une norme de codage informel dans la communauté Objective-C, et continue à ce jour.
L'analyse de la langue

Implémentations Objective-C utilisent un système d'exécution mince écrit en C, ce qui ajoute peu à la taille de l'application. En revanche, la plupart des systèmes orientés objet au moment où il a été créé utilisées grandes durées de fonctionnement des machines virtuelles. Les programmes écrits en Objective-C ont tendance à être pas beaucoup plus grande que la taille de leur code et que des bibliothèques (qui ne doivent généralement être inclus dans la distribution de logiciels), contrairement aux systèmes Smalltalk où une grande quantité de mémoire est utilisé seulement pour ouvrir une fenêtre. Applications en Objective-C ont tendance à être plus grandes que même C ou C + + applications parce que Objective-C typage dynamique ne permet pas de méthodes à décaper ou inline. Depuis le programmeur a une telle liberté de déléguer, transférer des appels, établir des sélecteurs à la volée et de les transmettre au système d'exécution, le compilateur Objective-C ne peut pas supposer qu'il est sûr de supprimer des méthodes non utilisées ou les appels à roues alignées.

De même, la langue peut être implémenté au-dessus de compilateurs C existants (dans GCC, d'abord comme un préprocesseur, puis comme un module) plutôt que comme un nouveau compilateur. Cela permet Objective-C pour tirer parti de l'énorme collection existante de code C, bibliothèques, outils, etc bibliothèques C existantes peuvent être emballés dans des emballages Objective-C pour fournir une interface OO-section. Dans cet aspect, il est semblable à la bibliothèque GObject et Vala langue, qui sont largement utilisés dans le développement d'applications GTK.

Tous ces changements pratiques abaissé la barrière à l'entrée, probablement le plus gros problème pour l'acceptation généralisée de Smalltalk dans les années 1980.

Les premières versions de l'Objective-C ne prennent pas en charge la collecte des ordures. Au moment où cette décision a été un sujet de débat, et beaucoup de gens ont longtemps considéré les "temps morts" (quand Smalltalk n'a collection) afin de rendre l'ensemble du système inutilisable. Certaines implémentations 3ème partie ont ajouté cette fonction (notamment GNUstep) et Apple a mis en place comme de Mac OS X v10.5. [27] Cependant, dans des versions plus récentes de Mac OS X et iOS, la collecte des ordures a été désapprouvé en faveur de ARC (voir ci-dessous).

Une autre critique commune est que Objective-C n'a pas de soutien linguistique pour les espaces de noms. Au lieu de cela, les programmeurs sont obligés d'ajouter des préfixes aux noms de classe, qui sont traditionnellement plus courte que les noms d'espaces de noms et donc plus sujettes aux collisions. À partir de 2007, toutes les classes de Mac OS X et des fonctions dans l'environnement de programmation Cocoa sont préfixés par «NS» (par exemple NSObject, NSButton) pour les identifier comme appartenant à la Mac OS X ou iOS noyau, le "NS" est dérivé des noms des classes telles que définies lors de l'élaboration de NeXTStep.

Depuis Objective-C est un sur-ensemble strict de C, il ne traite pas les types primitifs C comme objets de première classe.

Contrairement à C + +, Objective-C ne supporte pas la surcharge d'opérateur. Aussi, contrairement à C + +, Objective-C permet à un objet d'hériter directement que d'une classe (interdisant l'héritage multiple). Toutefois, les catégories et les protocoles peuvent être utilisés comme une alternative pour obtenir les mêmes résultats.

Parce que Objective-C utilise un typage d'exécution dynamique et parce que tous les appels de méthode sont des appels de fonction (ou, dans certains cas, syscalls), de nombreuses optimisations de performance communs peuvent pas être appliquées aux méthodes Objective-C (par exemple: inline, constante de propagation, les optimisations interprocédurales, et le remplacement scalaire de granulats). Cela limite les performances des abstractions Objective-C par rapport à des abstractions similaires dans des langages tels que C + + où ces optimisations sont possibles.

De nombreux programmeurs [Qui?] Aversion déchets collectés langues en raison des compromis de performance d'exécution. Apple a présenté automatique de comptage de références (ARC) en 2011 en tant que mécanisme de gestion de mémoire de remplacement. Avec ARC, le compilateur insère conserver et libérer automatiquement les appels en Objective-C du code basé sur l'analyse de code statique. L'automatisation soulage le programmeur d'avoir à écrire dans le code de gestion de la mémoire. ARC ajoute également des références faibles pour le langage Objective-C.
Différences philosophiques entre Objective-C et C + +

La conception et la mise en œuvre de C + + et Objective-C représentent différentes approches pour étendre C.

En plus du style de C de la programmation procédurale, C + + prend en charge directement certaines formes de la programmation orientée objet, programmation générique, et métaprogrammation. C + + est également livré avec une vaste bibliothèque standard qui comprend plusieurs classes de conteneurs. De même, Objective-C ajoute la programmation orientée objet, le typage dynamique, et la réflexion de C. Objective-C ne fournit pas une bibliothèque standard, en soi, mais dans la plupart des endroits où Objective-C est utilisé, il est utilisé avec un OpenStep- comme bibliothèque comme OPENSTEP, cacao, ou GNUstep, qui fournissent une fonctionnalité similaire à C + + 's bibliothèque standard.

Une différence notable est que Objective-C fournit un support d'exécution pour les fonctions de réflexion, alors que C + + ajoute seulement une petite quantité de support d'exécution de C. En Objective-C, un objet peut être interrogé sur ses propres propriétés, par exemple, si elle va répondre aux un certain message. En C + +, ce n'est pas possible sans l'utilisation de bibliothèques externes.

L'utilisation de la réflexion s'inscrit dans le cadre plus large de la distinction entre les caractéristiques dynamiques (run-time) versus statiques fonctionnalités (compilation) d'une langue. Bien que Objective-C et C + + chaque employer un mélange des deux fonctions, Objective-C est décidément orientée vers décisions d'exécution tandis que C + + est orientée vers des décisions de compilation. La tension entre la programmation dynamique et statique implique beaucoup de compromis classique en programmation: caractéristiques dynamiques ajoutent de la souplesse, les caractéristiques statiques ajouter la vitesse et la vérification de type.

Programmation générique et metaprogramming peuvent être mises en œuvre dans les deux langues en utilisant le polymorphisme de l'exécution; dans C + +, cela prend la forme de fonctions virtuelles et l'identification du type d'exécution, tout en Objective-C offre typage dynamique et la réflexion. Objective-C n'a pas polymorphisme moment de la compilation (génériques) entièrement, tandis que C + + ne supporte cette fonction via la surcharge et les modèles.
Published By Drupal french Study