Objetivo-C

En 1988, NeXT obtuvo la licencia de Objective-C de StepStone (el nuevo nombre de PPI, propietario de la marca registrada Objective-C) y amplió el compilador GCC para que fuera compatible con Objective-C. NeXT desarrolló las bibliotecas Application Kit (AppKit) y Foundation Kit, sobre las que se basaron la interfaz de usuario de NeXTSTEP y Interface Builder. Si bien las estaciones de trabajo de NeXT no tuvieron un gran impacto en el mercado, sus herramientas fueron ampliamente elogiadas en la industria. NeXT abandonó la producción de hardware y se centró en el desarrollo de software, comercializando NeXTSTEP (y OPENSTEP) como plataforma para programación personalizada.

Para eludir los términos de la GPL , NeXT tenía previsto inicialmente distribuir el frontend de Objective-C por separado, permitiendo al usuario enlazarlo con GCC para generar el ejecutable del compilador. Aunque inicialmente fue aceptado por Richard M. Stallman , este plan fue rechazado después de que Stallman consultara con los abogados de GNU y NeXT accediera a integrar Objective-C en GCC. ^{[ 12 ]}

El trabajo para extender GNU Compiler Collection (GCC) fue liderado por Steve Naroff, quien se unió a NeXT procedente de StepStone. Los cambios del compilador se publicaron bajo los términos de la Licencia Pública General de GNU (GPL), pero las bibliotecas de tiempo de ejecución no, lo que hizo que la contribución de código abierto no fuera utilizable por el público en general. Esto llevó a que otras partes desarrollaran dichas bibliotecas de tiempo de ejecución bajo licencias de código abierto. Posteriormente, Steve Naroff también fue uno de los principales colaboradores en el trabajo de Apple para construir el frontend de Objective-C para Clang . ^{[ 13 ]}

El proyecto GNU comenzó a trabajar en su implementación de software libre de Cocoa , llamada GNUstep , basada en el estándar OpenStep . ^{[ 14 ]} Dennis Glatting escribió el primer entorno de ejecución de GNU Objective-C en 1992. El entorno de ejecución de GNU Objective-C actual, en uso desde 1993, es el desarrollado por Kresten Krab Thorup mientras era estudiante universitario en Dinamarca . ^{[ 15 ]} Thorup también trabajó en NeXT de 1993 a 1996. ^{[ 16 ]}

Tras adquirir NeXT en 1996, Apple Computer utilizó OpenStep en su entonces nuevo sistema operativo, Mac OS X. Esto incluía Objective-C, la herramienta de desarrollo basada en Objective-C de NeXT, Project Builder , y su herramienta de diseño de interfaces, Interface Builder . Ambas se fusionaron posteriormente en una sola aplicación, Xcode . La mayor parte de la API Cocoa actual de Apple se basa en objetos de interfaz de OpenStep y es el entorno Objective-C más importante que se utiliza para el desarrollo activo.

En la Conferencia Mundial de Desarrolladores (WWDC) de 2014, Apple presentó un nuevo lenguaje, Swift , que se caracterizó como "Objective-C sin la C". ^{[ 17 ]}

El modelo Objective-C de programación orientada a objetos se basa en el paso de mensajes a instancias de objetos. En Objective-C, no se llama a un método ; se envía un mensaje . Esto difiere del modelo de programación estilo Simula utilizado por C++ . La diferencia entre estos dos conceptos radica en cómo se ejecuta el código referenciado por el nombre del método o mensaje. En un lenguaje estilo Simula, el nombre del método, en la mayoría de los casos, se vincula a una sección de código en la clase de destino mediante el compilador. En Smalltalk y Objective-C, el destino de un mensaje se resuelve en tiempo de ejecución, y el objeto receptor interpreta el mensaje. Un método se identifica mediante un selector o SELun identificador único para cada nombre de mensaje, a menudo una cadena terminada en que representa su nombre, y se resuelve en un puntero a un método C que lo implementa : un . ^{[ 22 ]} Una consecuencia de esto es que el sistema de paso de mensajes no tiene comprobación de tipos. No se garantiza que el objeto al que se dirige el mensaje —el receptor— responda a un mensaje, y si no lo hace, genera una excepción. ^{[ 23 ]}NULIMP

Para enviar el mensaje methodal objeto al que apunta el puntero, objse necesitaría el siguiente código en C++ :

obj -> método ( argumento );

En Objective-C, esto se escribe de la siguiente manera:

[ método obj : argumento ];

La llamada al "método" es traducida por el compilador a la objc_msgSend(id self, SEL op, ...)familia de funciones de tiempo de ejecución. ^{[ 24 ]} Diferentes implementaciones manejan adiciones modernas como super. ^{[ 25 ]} En las familias GNU, esta función se llama objc_msg_sendv, pero ha sido descontinuada en favor de un sistema de búsqueda moderno en objc_msg_lookup. ^{[ 26 ]}

Ambos estilos de programación presentan múltiples ventajas y desventajas. La programación orientada a objetos en el estilo Simula ( C++ ) permite la herencia múltiple y una ejecución más rápida mediante el enlace en tiempo de compilación siempre que sea posible, pero no admite el enlace dinámico por defecto. Además, obliga a que todos los métodos tengan una implementación correspondiente, a menos que sean abstractos . La programación al estilo Smalltalk, utilizada en Objective-C, permite que los mensajes no estén implementados, y que el método se resuelva a su implementación en tiempo de ejecución. Por ejemplo, se puede enviar un mensaje a una colección de objetos, de los cuales solo algunos responderán, sin temor a producir errores en tiempo de ejecución. El paso de mensajes tampoco requiere que un objeto esté definido en tiempo de compilación . Sin embargo, se requiere una implementación para que el método se llame en el objeto derivado. (Consulte la sección de tipado dinámico a continuación para obtener más información sobre las ventajas del enlace dinámico (tardío)).

Objective-C requiere que la interfaz y la implementación de una clase se declaren en bloques de código separados. Por convención, los desarrolladores colocan la interfaz en un archivo de cabecera y la implementación en un archivo de código. Los archivos de cabecera, normalmente con la extensión .h, son similares a los archivos de cabecera de C, mientras que los archivos de implementación (métodos), normalmente con la extensión .m, pueden ser muy similares a los archivos de código de C.

@interface ClassName : SuperclassName { // variables de instancia } + classMethod1 ; + ( return_type ) classMethod2 ; + ( return_type ) classMethod3: ( param1_type ) param1_varName ;- ( tipo_retorno ) método_instancia1con1parámetro: ( tipo_param1 ) nombre_var_param1 ; - ( tipo_retorno ) método2con2parámetros de instancia: ( tipo_param1 ) nombre_var_param1 nombre_llamada_param : (tipo_param2 ) nombre_var_param2 ; @fin

clase ClassName : public SuperclassName { protected : // variables de instanciapúblico : // Funciones de clase (estáticas) static void * classMethod1 (); static return_type classMethod2 (); static return_type classMethod3 ( param1_type param1_varName );// Funciones de instancia (miembro) return_type instanceMethod1With1Parameter ( param1_type param1_varName ); return_type instanceMethod2With2Parameters ( param1_type param1_varName , param2_type param2_varName = default ); };

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

@implementation classname + ( return_type ) classMethod { // implementación } - ( return_type ) instanceMethod { // implementación } @end

- ( int ) método: ( int ) i { return [ self raíz_cuadrada : i ]; }

función entera ( int i ) { devuelve raíz cuadrada ( i ); }

- ( void ) changeColorToRed: ( float ) red green: ( float ) green blue: ( float ) blue { //... Implementación ... }// Llamado de esta manera: [ myColor changeColorToRed : 5.0 green : 2.0 blue : 6.0 ];

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

MyObject * foo = [[ MyObject alloc ] initWithString : myString ];

MyObject * foo = [ MyObject new ];

MyObject * foo = [ MyObject object ]; MyObject * bar = [ MyObject objectWithString : @"Wikipedia :)" ];

- ( id ) init {self = [ super init ];si ( self ) {// Inicializa el objeto aquí}regresar a sí mismo ;}

En otros lenguajes de programación, se les llama interfaces .

Objective-C se amplió en NeXT para introducir el concepto de herencia múltiple de especificaciones, pero no de implementación, mediante la introducción de protocolos . Este patrón se puede lograr como una clase base abstracta de herencia múltiple en C++ o como una interfaz (como en Java y C# ). Objective-C utiliza protocolos ad hoc, denominados protocolos informales , y protocolos impuestos por el compilador, denominados protocolos formales .

Un protocolo informal es una lista de métodos que una clase puede optar por implementar. Se especifica en la documentación, ya que no está presente en el lenguaje. Los protocolos informales se implementan como una categoría (véase más abajo) en NSObject y suelen incluir métodos opcionales que, si se implementan, pueden cambiar el comportamiento de una clase. Por ejemplo, una clase de campo de texto podría tener un delegado que implemente un protocolo informal con un método opcional para realizar el autocompletado del texto escrito por el usuario. El campo de texto descubre si el delegado implementa ese método (mediante programación reflexiva ) y, en caso afirmativo, llama al método del delegado para habilitar la función de autocompletado.

Un protocolo formal es similar a una interfaz en Java, C# y Ada 2005. Se trata de una lista de métodos que cualquier clase puede declarar que implementará. Las versiones de Objective-C anteriores a la 2.0 requerían que una clase implementara todos los métodos de un protocolo que declarara adoptar; el compilador generaría un error si la clase no implementaba todos los métodos de sus protocolos declarados. Objective-C 2.0 añadió soporte para marcar ciertos métodos de un protocolo como opcionales, y el compilador no exigirá la implementación de métodos opcionales.

Para que una clase se considere conforme a un protocolo, debe declararse que lo implementa. Esto se puede detectar en tiempo de ejecución. Los protocolos formales no proporcionan implementaciones; simplemente garantizan a quienes los utilizan que las clases que se ajustan al protocolo sí las proporcionarán. En la biblioteca NeXT/Apple, el sistema de objetos distribuidos utiliza con frecuencia protocolos para representar las capacidades de un objeto que se ejecuta en un sistema remoto.

La sintaxis

@protocol NSLocking - ( void ) lock ; - ( void ) unlock ; @end

denota que existe la idea abstracta de bloqueo. Al indicar en la definición de la clase que el protocolo está implementado,

@interface NSLock : NSObject < NSLocking > // ... @end

Las instancias de NSLock afirman que proporcionarán una implementación para los dos métodos de instancia.

Objective-C, al igual que Smalltalk, puede usar tipado dinámico : se puede enviar un mensaje a un objeto que no esté especificado en su interfaz. Esto permite una mayor flexibilidad, ya que permite que un objeto "capture" un mensaje y lo envíe a otro objeto que pueda responder adecuadamente, o bien, que lo envíe a otro objeto. Este comportamiento se conoce como reenvío de mensajes o delegación (véase más abajo). Alternativamente, se puede usar un manejador de errores en caso de que el mensaje no se pueda reenviar. Si un objeto no reenvía un mensaje, no responde a él o no maneja un error, el sistema generará una excepción en tiempo de ejecución. ^{[ 29 ]} Si los mensajes se envían a nil (el puntero de objeto nulo), se ignorarán silenciosamente o generarán una excepción genérica, según las opciones del compilador.

También se puede añadir información de tipado estático a las variables de forma opcional. Esta información se verifica en tiempo de compilación. En las siguientes cuatro instrucciones, se proporciona información de tipo cada vez más específica. Las instrucciones son equivalentes en tiempo de ejecución, pero la información adicional permite al compilador advertir al programador si el argumento pasado no coincide con el tipo especificado.

- ( void ) setMyValue: ( id ) foo ;

En la declaración anterior, foo puede ser de cualquier clase.

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

En la declaración anterior, foo puede ser una instancia de cualquier clase que cumpla con el NSCopyingprotocolo.

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

En la declaración anterior, foo debe ser una instancia de la clase NSNumber .

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

En la declaración anterior, foo debe ser una instancia de la clase NSNumber y debe ajustarse al NSCopyingprotocolo.

En Objective-C, todos los objetos se representan como punteros y no se permite la inicialización estática. El objeto más simple es el tipo al que apunta `id ( objc_obj * )`, que solo tiene un puntero `isa` que describe su clase. Otros tipos de C, como los valores y las estructuras, permanecen sin cambios porque no forman parte del sistema de objetos. Esta decisión difiere del modelo de objetos de C++, donde las estructuras y las clases están unificadas.

Objective-C permite enviar un mensaje a un objeto que puede no responder. En lugar de responder o simplemente descartar el mensaje, un objeto puede reenviarlo a otro que sí pueda responder. El reenvío puede utilizarse para simplificar la implementación de ciertos patrones de diseño , como el patrón observador o el patrón proxy .

El entorno de ejecución de Objective-C especifica un par de métodos enObject

• métodos de reenvío:

  - ( retval_t ) forward: ( SEL ) sel args: ( arglist_t ) args ; // con GCC - ( id ) forward: ( SEL ) sel args: ( marg_list ) args ; // con sistemas NeXT/Apple

• métodos de acción:

  - ( retval_t ) performv: ( SEL ) sel args: ( arglist_t ) args ; // con GCC - ( id ) performv: ( SEL ) sel args: ( marg_list ) args ; // con sistemas NeXT/Apple

Un objeto que desee implementar el reenvío solo necesita sobrescribir el método de reenvío con un nuevo método para definir el comportamiento de reenvío. performv::No es necesario sobrescribir el método de acción, ya que este simplemente realiza una acción en función del selector y los argumentos. Observe el SELtipo, que es el tipo de mensajes en Objective-C.

Nota: en OpenStep, Cocoa y GNUstep, los frameworks más utilizados de Objective-C, no se utiliza la Objectclase. El método de la clase se utiliza para realizar el reenvío.-(void)forwardInvocation:(NSInvocation*)anInvocationNSObject

#importar <objc/Object.h>@interface Forwarder : Object { id recipient ; // El objeto al que queremos reenviar el mensaje. }// Métodos de acceso. - ( id ) destinatario ; - ( id ) setRecipient: ( id ) _destinatario ; @end

#importar "Forwarder.h"@implementation Forwarder - ( retval_t ) forward: ( SEL ) sel args: ( arglist_t ) args { /*  * Comprueba si el destinatario realmente responde al mensaje.  * Esto puede ser deseable o no; por ejemplo, si un destinatario  * a su vez no responde al mensaje, podría reenviarlo  * por sí mismo.  */ if ([ recipient respondsToSelector : sel ]) { return [ recipient performv : sel args : args ]; } else { return [ self error : "El destinatario no responde" ]; } }- ( id ) setRecipient: ( id ) _recipient { [ recipient autorelease ]; recipient = [ _recipient retain ]; return self ; }- ( id ) destinatario { devolver destinatario ; } @end

#importar <objc/Object.h>// Un objeto Recipient simple. @interface Recipient : Object - ( id ) hello ; @end

#importar "Recipient.h"@destinatario de la implementación- ( id ) hola { printf ( "El destinatario dice hola! \n " );devolver self ; }@fin

#importar "Forwarder.h" #importar "Recipient.h"int main ( void ) { Forwarder * forwarder = [ Forwarder new ]; Recipient * recipient = [ Recipient new ];[ forwarder setRecipient : recipient ]; // Establecer el destinatario. /*  * ¡Observe que forwarder no responde a un mensaje hello! Será  * reenviado. Todos los métodos no reconocidos serán reenviados al  * destinatario  * (si el destinatario responde a ellos, como está escrito en Forwarder)  */ [ forwarder hello ];[ liberación del destinatario ]; [ liberación del remitente ];devolver 0 ; }

$ gcc -x objective-c -Wno-import Forwarder.m Recipient.m main.m -lobjc main.m: En la función `main': main.m:12: advertencia: `Forwarder' no responde a `hello' $

$ ./a.out ¡ El destinatario dice hola!

Durante el diseño de Objective-C, una de las principales preocupaciones fue la mantenibilidad de grandes bases de código. La experiencia en el mundo de la programación estructurada había demostrado que una de las principales maneras de mejorar el código era dividirlo en partes más pequeñas. Inspirándose en los mixins del Common Lisp Object System , se desarrolló el concepto de categorías de Objective-C para facilitar este proceso. ^{[ 30 ]}

Las categorías permiten ampliar dinámicamente los métodos de una clase en tiempo de ejecución . Esto posibilitó que el programador utilizara clases abiertas sin necesidad de recompilar la clase ni siquiera tener acceso a su código fuente. Por ejemplo, si un sistema no incluye un corrector ortográfico en su implementación de String, este podría añadirse sin modificar el código fuente de String. ^{[ 30 ]}

Cuando se ejecuta el programa, los métodos dentro de las categorías se vuelven indistinguibles de los métodos de una clase. Una categoría tiene acceso completo a todas las variables de instancia dentro de la clase, incluidas las variables privadas.

Si una categoría declara un método con la misma firma que un método existente en una clase, se adopta el método de la categoría. Por lo tanto, las categorías no solo pueden agregar métodos a una clase, sino también reemplazar métodos existentes. Esta característica se puede usar para corregir errores en otras clases reescribiendo sus métodos, o para provocar un cambio global en el comportamiento de una clase dentro de un programa. Si dos categorías tienen métodos con el mismo nombre pero diferentes firmas, no se define qué método de la categoría se adopta.

Otros lenguajes han intentado incorporar esta funcionalidad de diversas maneras. TOM fue un paso más allá en el sistema Objective-C y permitió la adición de variables. Otros lenguajes han utilizado soluciones basadas en prototipos , siendo Self la más destacada .

Los lenguajes C# y Visual Basic (.NET) implementan funciones superficialmente similares en forma de métodos de extensión , ^{[ 30 ]} pero estos carecen de acceso a las variables privadas de la clase. ^{[ 31 ]} Ruby y otros lenguajes de programación dinámica se refieren a esta técnica como " monkey patching ".

Logtalk implementa un concepto de categorías (como entidades de primera clase) que engloba la función de categorías de Objective-C (las categorías de Logtalk también se pueden utilizar como unidades de composición de grano fino al definir, por ejemplo, nuevas clases o prototipos; en particular, una categoría de Logtalk puede ser importada virtualmente por cualquier número de clases y prototipos).

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

Objective-C permite que una clase reemplace por completo a otra dentro de un programa. Se dice que la clase que reemplaza "se hace pasar" por la clase objetivo.

La función de posicionamiento de clases se declaró obsoleta con Mac OS X v10.5 y no está disponible en el entorno de ejecución de 64 bits . Se puede lograr una función similar utilizando la técnica de intercambio de métodos en categorías, que consiste en intercambiar la implementación de un método con la de otro que tenga la misma firma.

Para las versiones que aún admiten el posicionamiento, todos los mensajes enviados a la clase de destino son recibidos por la clase de posicionamiento. Existen varias restricciones:

• Una clase solo puede presentarse como una de sus superclases directas o indirectas.
• La clase que realiza la solicitud no debe definir ninguna variable de instancia nueva que no esté presente en la clase de destino (aunque puede definir o sobrescribir métodos).
• Es posible que la clase objetivo no haya recibido ningún mensaje antes de la solicitud.

El posado, al igual que las categorías, permite una ampliación global de las clases existentes. El posado permite dos características ausentes en las categorías:

• Una clase que realiza la operación puede llamar a métodos sobrescritos a través de super, incorporando así la implementación de la clase de destino.
• Una clase de pose puede sobrescribir los métodos definidos en las categorías.

Por ejemplo,

@interface CustomNSApplication : NSApplication @end@implementation CustomNSApplication - ( void ) setMainMenu: ( NSMenu * ) menu { // hacer algo con menu } @endclass_poseAs ([ Clase CustomNSApplication ], [ Clase NSApplication ]);

Esto intercepta cada invocación de setMainMenu a NSApplication.

En el lenguaje C, la #includedirectiva pre-compile siempre hace que el contenido de un archivo se inserte en el código fuente en ese punto. Objective-C tiene la #importdirectiva, equivalente excepto que cada archivo se incluye solo una vez por unidad de compilación, lo que elimina la necesidad de protecciones de inclusión .

La directiva Objective-C no debe confundirse con la palabra clave de C++ , que se utiliza para importar módulosimport de C++ (desde C++20 ) y no es una directiva de preprocesador. Tampoco debe confundirse con la directiva de preprocesador en Microsoft Visual C++ (MSVC), que no es estándar y se utiliza para importar bibliotecas de tipos. ^{[ 32 ]}#import

En la Conferencia Mundial de Desarrolladores de 2006 , Apple anunció el lanzamiento de "Objective-C 2.0", una revisión del lenguaje Objective-C que incluía "recolección de basura moderna, mejoras de sintaxis, ^{[ 33 ]} mejoras de rendimiento en tiempo de ejecución, ^{[ 34 ]} y compatibilidad con 64 bits". Mac OS X v10.5 , lanzado en octubre de 2007, incluía un compilador Objective-C 2.0. GCC 4.6 admite muchas características nuevas de Objective-C, como propiedades declaradas y sintetizadas, sintaxis de punto, enumeración rápida, métodos de protocolo opcionales, atributos de método/protocolo/clase, extensiones de clase y una nueva API de tiempo de ejecución de GNU Objective-C. ^{[ 35 ]}

La denominación Objective-C 2.0 representa una ruptura en el sistema de versiones del lenguaje, ya que la última versión de Objective-C para NeXT fue "objc4". ^{[ 36 ]} Este nombre de proyecto se mantuvo en la última versión del código fuente del entorno de ejecución de Objective-C heredado en Mac OS X Leopard (10.5). ^{[ 37 ]}

@interface Person : NSObject { @public NSString * name ; @private int age ; }@property ( copia ) NSString * nombre ; @property ( solo lectura ) int edad ;- ( id ) initWithAge: ( int ) age ; @end

@implementación Persona @sintetizar nombre ;- ( id ) initWithAge: ( int ) initAge { self = [ super init ]; if ( self ) { // NOTA: asignación directa de variable de instancia, no setter de propiedad age = initAge ; } return self ; }- ( int ) edad { return edad ; } @end

Persona * aPersona = [[ Persona alloc ] initWithAge : 53 ]; aPersona . nombre = @"Steve" ; // NOTA: notación de punto, usa setter sintetizado, // equivalente a [aPersona setName: @"Steve"]; NSLog ( @"Acceso por mensaje (%@), notación de punto (%@), nombre de propiedad (% @) y " "acceso directo a variable de instancia (% @) " , [ aPersona nombre ], aPersona . nombre , [ aPersona valueForKey : @"nombre" ], aPersona -> nombre );

- ( void ) introduceMyselfWithProperties: ( BOOL ) useGetter { NSLog ( @"Hola, mi nombre es %@." , ( useGetter ? self . name : name )); // NOTA: acceso mediante getter vs. ivar }

int i ; int propertyCount = 0 ; objc_property_t * propertyList = class_copyPropertyList ([ aPerson class ], & propertyCount );for ( i = 0 ; i < propertyCount ; i ++ ) { objc_property_t * thisProperty = propertyList + i ; const char * propertyName = property_getName ( * thisProperty ); NSLog ( @"La persona tiene una propiedad: '%s'" , propertyName ); }

// Usando NSEnumerator NSEnumerator * enumerator = [ thePeople objectEnumerator ]; Person * p ;while (( p = [ enumerator nextObject ]) != nil ) { NSLog ( @"%@ tiene %i años." , [ p nombre ], [ p edad ]); }

// Usando índices for ( int i = 0 ; i < [ thePeople count ]; i ++ ) { Person * p = [ thePeople objectAtIndex : i ]; NSLog ( @"%@ tiene %i años." , [ p name ], [ p age ]); }

// Usando enumeración rápida for ( Person * p in thePeople ) { NSLog ( @"%@ tiene %i años." , [ p nombre ], [ p edad ]); }

Blocks es una extensión para Objective-C (y C y C++ ) que utiliza una sintaxis especial para crear cierres . Blocks solo es compatible con Mac OS X 10.6 "Snow Leopard" o posterior, iOS 4 o posterior, y GNUstep con libobjc2 1.7 y compilando con clang 3.1 o posterior. ^{[ 46 ]}

#include <stdio.h> #include <Block.h> typedef int ( ^ IntBlock )();IntBlock MakeCounter ( int start , int increment ) { __block int i = start ;return Block_copy ( ^ { int ret = i ; i += increment ; return ret ; });}int main ( void ) { IntBlock mycounter = MakeCounter ( 5 , 2 ); printf ( "Primera llamada: %d \n " , mycounter ()); printf ( "Segunda llamada: %d \n " , mycounter ()); printf ( "Tercera llamada: %d \n " , mycounter ());/* porque fue copiado, también debe ser liberado */ Block_release ( mycounter );return 0 ; } /* Salida:  Primera llamada: 5  Segunda llamada: 7  Tercera llamada: 9 */

Apple ha añadido algunas características adicionales a Objective 2.0 con el tiempo. Apple describe estos cambios como aplicables únicamente al " compilador LLVM de Apple " (clang), pero también se encuentran en versiones de código abierto de clang. Resulta confuso que el sistema de versiones utilizado por Apple difiera del de LLVM; consulte Xcode §  Versiones de la cadena de herramientas para obtener una traducción a los números de versión de LLVM de código abierto. ^{[ 47 ]}

NSArray * myArray = [ NSArray arrayWithObjects : object1 , object2 , object3 , nil ]; NSDictionary * myDictionary1 = [ NSDictionary dictionaryWithObject : someObject forKey : @"key" ]; NSDictionary * myDictionary2 = [ NSDictionary dictionaryWithObjectsAndKeys : object1 , key1 , object2 , key2 , nil ]; NSNumber * myNumber = [ NSNumber numberWithInt : myInt ]; NSNumber * mySumNumber = [ NSNumber numberWithInt : ( 2 + 3 )]; NSNumber * myBoolNumber = [ NSNumber numberWithBool : YES ];

NSArray * myArray = @[ object1 , object2 , object3 ] ; NSDictionary * myDictionary1 = @{ @"key" : someObject } ; NSDictionary * myDictionary2 = @{ key1 : object1 , key2 : object2 } ; NSNumber * myNumber = @( myInt ) ; NSNumber * mySumNumber = @( 2 + 3 ) ; NSNumber * myBoolNumber = @YES ; NSNumber * myIntegerNumber = @8 ;

id objeto1 = [ someArray objetoEnÍndice : 0 ]; id objeto2 = [ someDictionary objetoParaClave : @"clave" ]; [ someMutableArray reemplazarObjetoEnÍndice : 0 conObjeto : objeto3 ]; [ someMutableDictionary establecerObjeto : objeto4 paraClave : @"clave" ];

id objeto1 = someArray [ 0 ]; id objeto2 = someDictionary [ @"key" ]; someMutableArray [ 0 ] = objeto3 ; someMutableDictionary [ @"key" ] = objeto4 ;

Objective-C++ es una variante de lenguaje aceptada por el front-end de GNU Compiler Collection y Clang , que puede compilar archivos fuente que utilizan una combinación de sintaxis de C++ y Objective-C. Fue desarrollado por NeXT a petición de Lotus Development durante el desarrollo del programa de hoja de cálculo Improv en 1989. ^{[ 55 ]} El término "Objective-C++" también apareció en la documentación de Apple para su compilador Objective-C, pero posteriormente fue eliminado. ^{[ 56 ]}

Objective-C++ añade a C++ las extensiones que Objective-C añade a C. Como no se hace nada para unificar la semántica de las distintas características del lenguaje, se aplican ciertas restricciones:

• Una clase de C++ no puede heredar de una clase de Objective-C y viceversa. ^{[ 55 ]}
• Los espacios de nombres de C++ no se pueden declarar dentro de una declaración de Objective-C.
• Las declaraciones de Objective-C solo pueden aparecer en el ámbito global, no dentro de un espacio de nombres de C++.
• Las clases de Objective-C no pueden tener variables de instancia de clases de C++ que carezcan de un constructor predeterminado o que tengan uno o más métodos virtuales , pero los punteros a objetos de C++ se pueden usar como variables de instancia sin restricciones (asígnelos con new en el método -init).
• La semántica "por valor" de C++ no se puede aplicar a los objetos de Objective-C, que solo son accesibles a través de punteros.
• Una declaración de Objective-C no puede estar dentro de una declaración de plantilla de C++ y viceversa. Sin embargo, los tipos de Objective-C (por ejemplo, Classname *) pueden usarse como parámetros de plantilla de C++.
• El manejo de excepciones en Objective-C y C++ es distinto; los manejadores de cada uno no pueden manejar excepciones del otro tipo. Como resultado, los destructores de objetos no se ejecutan. Esto se mitiga en las versiones recientes de "Objective-C 2.0" , ya que las excepciones de Objective-C se reemplazan completamente por excepciones de C++ (entorno de ejecución de Apple) o parcialmente cuando se enlaza la biblioteca de Objective-C++ ( GNUStep libobjc2). ^{[ 56 ]}
• Los bloques de Objective-C y las expresiones lambda de C++11 son entidades distintas. Sin embargo, en macOS se genera un bloque de forma transparente al pasar una expresión lambda donde se espera un bloque. ^{[ 57 ]}

Tras la compra de NeXT por parte de Apple, se intentó que el lenguaje resultara más aceptable para programadores más familiarizados con Java que con Smalltalk. Uno de estos intentos fue la introducción de lo que en aquel momento se denominó "Sintaxis Moderna" para Objective-C ^{[ 58 ]} (en contraste con la sintaxis "clásica" actual). No hubo ningún cambio en el comportamiento; se trataba simplemente de una sintaxis alternativa. En lugar de escribir una invocación de método como:

objeto = [[ MyClass alloc ] init ]; [ objeto firstLabel : param1 secondLabel : param2 ];

En cambio, fue escrito como

objeto = ( MyClass . alloc ). init ; objeto . labels ( param1 , param2 );

De manera similar, las declaraciones pasaron de la forma

- ( void ) firstLabel : ( int ) param1 secondLabel : ( int ) param2 ;

a

- ( void ) etiquetas ( int param1 , int param2 );

Esta sintaxis "moderna" ya no es compatible con las variantes actuales del lenguaje Objective-C.

El proyecto GNU ha estado interesado durante mucho tiempo en una plataforma para portar programas NeXT y Obj-C. El registro de cambios del directorio libobjc en GCC sugiere que existía antes de 1998 (GCC 2.95), y su archivo README indica además una reescritura en 1993 (GCC 2.4). ^{[ 59 ]}

El código fuente del frontend de NeXT se publicó ya que se creó como parte de GCC, publicado bajo la Licencia Pública General de GNU, que obliga a quienes crean obras derivadas a hacerlo. Apple continuó esta tradición publicando su bifurcación de GCC hasta la versión 4.2.1, después de la cual abandonaron el compilador. Los mantenedores de GCC tomaron en cuenta los cambios, pero no invirtieron mucho en dar soporte a características más recientes como el lenguaje Objective-C 2.0. ^{[ 36 ] : ¿Qué compilador?}

Los desarrolladores de GNUstep, interesados ​​en el nuevo lenguaje, bifurcaron la biblioteca libobjc de GCC en un proyecto independiente de GCC llamado libobjc2 en 2009. También dispusieron que el entorno de ejecución se utilizara con Clang para aprovechar la nueva sintaxis del lenguaje. ^{[ 36 ] : ¿Qué compilador} ? GCC avanzó lentamente al mismo tiempo, pero en GCC 4.6.0 (2011) también pasaron a Objective-C 2.0 en su libobjc. ^{[ 35 ] [ 60 ]} La documentación de GNUstep sugiere que la implementación de GCC todavía carece de soporte para bloques, variables no frágiles y el ARC más reciente. ^{[ 36 ] : ¿Qué entorno de ejecución?}

Microsoft bifurcó el entorno de ejecución de ObjFW en una parte de WinObjC , el puente de iOS para la Plataforma Universal de Windows , en 2015, aunque cambió a una bifurcación de libobjc2 en 2016. Combinado con su propia implementación de Cocoa Touch y las API subyacentes, el proyecto permite la reutilización del código de las aplicaciones de iOS dentro de las aplicaciones UWP. ^{[ 61 ]}

En Windows, las herramientas de desarrollo de Objective-C están disponibles para su descarga en el sitio web de GNUStep. El sistema de desarrollo de GNUStep consta de los siguientes paquetes: GNUstep MSYS System, GNUstep Core, GNUstep Devel, GNUstep Cairo, ProjectCenter IDE (similar a Xcode, pero menos complejo) y Gorm (generador de interfaces similar al generador de NIB de Xcode). Estos instaladores binarios no se han actualizado desde 2016, ^{[ 62 ]} por lo que podría ser mejor instalarlos compilando con Cygwin o MSYS2 .

El conjunto de compiladores Clang , parte del proyecto LLVM , implementa Objective-C y otros lenguajes. Después de que GCC 4.3 (2008) adoptara la licencia GPLv3, Apple lo abandonó en favor de Clang, un compilador que tiene mayor libertad legal para modificar. Como resultado, muchas de las características modernas del lenguaje Objective-C solo son compatibles con Clang. ^{[ 47 ]}

El esquema de versiones de Apple para su compilador LLVM basado en clang difiere del esquema de versiones de código abierto de LLVM. Consulte Xcode §  Versiones de la cadena de herramientas para obtener una traducción. ^{[ 47 ]}

mulle-objc es una implementación de Objective-C orientada al rendimiento. Utiliza una biblioteca de tiempo de ejecución escrita en C11 puro , lo que garantiza la portabilidad (entre otras plataformas, admite Linux, FreeBSD y Windows). La biblioteca de tiempo de ejecución se puede enlazar estáticamente con musl . Utiliza una bifurcación de clang/LLVM como compilador y una bifurcación de gdb como depurador. ^{[ 63 ] [ 64 ]} Mulle-objc tiene un conjunto de características intencionalmente reducido, que se describe mejor como "Objective-C 1.0 con algunas características 2.0 seleccionadas". ^{[ 65 ]}

El Portable Object Compiler (POC) era una implementación alternativa de Objective-C. El conjunto de extensiones implementadas por el POC difiere de la implementación de GCC/NeXT/Apple; en particular, incluye bloques similares a Smalltalk para Objective-C, mientras que carece de protocolos y categorías, dos características ampliamente utilizadas en OpenStep y sus derivados y parientes. En general, el POC representa una etapa anterior, previa a NeXT, en la evolución del lenguaje, que se ajusta aproximadamente al libro de Brad Cox de 1991. ^{[ 66 ]}

También incluye una biblioteca de tiempo de ejecución llamada ObjectPak, que se basa en la biblioteca original ICPak101 de Cox (que a su vez deriva de la biblioteca de clases Smalltalk-80) y es radicalmente diferente de OpenStep FoundationKit.

Las primeras versiones de Objective-C no admitían la recolección de basura (GC). En aquel entonces, esta decisión generó cierto debate, y muchos consideraban que los largos periodos de inactividad (cuando Smalltalk realizaba la recolección) hacían que todo el sistema fuera inutilizable. Algunas implementaciones de terceros han añadido esta función, en particular GNUstep, que utiliza el recolector de basura Boehm .

Apple implementó GC como parte de Objective-C 2.0 a partir de Mac OS X v10.5 . ^{[ 67 ]} La nueva característica resultó impopular entre los desarrolladores; Apple no convirtió ninguna de sus aplicaciones internas para usar GC, aparte de Xcode . ^{[ 17 ]} La adopción se vio gravemente obstaculizada por el hecho de que GC no se hizo disponible en el iPhone debido a preocupaciones sobre el rendimiento del software . ^{[ 17 ] [ 67 ]} En versiones más recientes de macOS, la recolección de basura ha sido obsoleta en favor del Conteo Automático de Referencias (ARC), introducido en 2011. ^{[ 17 ]}

Con ARC, el compilador inserta automáticamente llamadas a retain y release en el código Objective-C basándose en el análisis estático del código . Esta automatización libera al programador de la necesidad de escribir código para la gestión de memoria. ARC también añade referencias débiles al lenguaje Objective-C. ^{[ 68 ] [ 69 ]}

El diseño y la implementación de C++ y Objective-C representan enfoques fundamentalmente diferentes para extender C.

Además del estilo de programación procedimental de C, C++ admite directamente ciertas formas de programación orientada a objetos , programación genérica y metaprogramación . C++ también incluye una amplia biblioteca estándar con varias clases contenedoras . De manera similar, Objective-C añade programación orientada a objetos , tipado dinámico y reflexión a C. Objective-C no proporciona una biblioteca estándar propiamente dicha , pero en la mayoría de los casos donde se utiliza, se combina con una biblioteca similar a OpenStep , como OPENSTEP , Cocoa o GNUstep , que ofrece funciones parecidas a las de la biblioteca estándar de C++.

Una diferencia notable es que Objective-C ofrece soporte en tiempo de ejecución para funciones de programación reflexiva , mientras que C++ solo añade un soporte limitado a C. En Objective-C, se puede consultar sobre las propiedades de un objeto, por ejemplo, si responderá a un mensaje determinado. En C++, esto no es posible sin el uso de bibliotecas externas.

El uso de la reflexión forma parte de la distinción más amplia entre las características dinámicas (de tiempo de ejecución) y estáticas (de tiempo de compilación) de un lenguaje. Si bien Objective-C y C++ emplean una combinación de ambas, Objective-C prioriza las decisiones de tiempo de ejecución, mientras que C++ las prioriza de tiempo de compilación. La tensión entre la programación dinámica y estática implica muchas de las disyuntivas clásicas de la programación: las características dinámicas aportan flexibilidad, mientras que las estáticas aportan velocidad y verificación de tipos.

La programación genérica y la metaprogramación pueden implementarse en ambos lenguajes mediante polimorfismo en tiempo de ejecución ( despacho dinámico ). En C++, esto se manifiesta en forma de funciones virtuales e identificación de tipos en tiempo de ejecución , mientras que Objective-C ofrece tipado dinámico y reflexión. Tanto Objective-C como C++ admiten polimorfismo en tiempo de compilación ( funciones genéricas ), característica que Objective-C incorporó en 2015.