b'\n_START_ARTICLE_\nObjective-C\n_START_SECTION_\nHistoria\n_START_PARAGRAPH_\nA principios de los 80, el software se desarrollaba usando programaci\xc3\xb3n estructurada. La programaci\xc3\xb3n estructurada se estableci\xc3\xb3 para ayudar a dividir los programas en peque\xc3\xb1as partes, haciendo m\xc3\xa1s f\xc3\xa1cil el desarrollo cuando la aplicaci\xc3\xb3n se volv\xc3\xada muy grande. Sin embargo, como los problemas segu\xc3\xadan creciendo al pasar el tiempo, la programaci\xc3\xb3n estructurada se volvi\xc3\xb3 compleja dado el desorden de algunos programadores para invocar instrucciones repetitivamente, llevando a c\xc3\xb3digo spaghetti y dificultando la reutilizaci\xc3\xb3n de c\xc3\xb3digo._NEWLINE_Muchos vieron que la programaci\xc3\xb3n orientada a objetos ser\xc3\xada la soluci\xc3\xb3n al problema. De hecho, Smalltalk ya ten\xc3\xada solucionados muchos de estos problemas: algunos de los sistemas m\xc3\xa1s complejos en el mundo funcionaban gracias a Smalltalk. Pero Smalltalk usaba una m\xc3\xa1quina virtual, lo cual requer\xc3\xada mucha memoria para esa \xc3\xa9poca, y era demasiado lento._NEWLINE_Objective-C fue creado principalmente por Brad Cox y Tom Love a inicios de los 80 en su compa\xc3\xb1\xc3\xada Stepstone. Ambos fueron iniciados en Smalltalk mientras estaban en el Programming Technology Center de ITT en 1981. Cox se vio interesado en los problemas de reutilizaci\xc3\xb3n en el desarrollo de software. Se dio cuenta de que un lenguaje como Smalltalk ser\xc3\xada imprescindible en la construcci\xc3\xb3n de entornos de desarrollo potentes para los desarrolladores en ITI Corporation. Cox empez\xc3\xb3 a modificar el compilador de C para agregar algunas de las capacidades de Smalltalk. Pronto tuvo una extensi\xc3\xb3n para a\xc3\xb1adir la programaci\xc3\xb3n orientada a objetos a C la cual llam\xc3\xb3 \xc2\xabOOPC\xc2\xbb (Object-Oriented Programming in C). Love mientras tanto, fue contratado por Shlumberger Research en 1982 y tuvo la oportunidad de adquirir la primera copia de Smalltalk-80, lo que influy\xc3\xb3 en su estilo como programador._NEWLINE_Para demostrar que se hizo un progreso real, Cox mostr\xc3\xb3 que para hacer componentes de software verdaderamente intercambiables s\xc3\xb3lo se necesitaban unos peque\xc3\xb1os cambios en las herramientas existentes. Espec\xc3\xadficamente, estas necesitaban soportar objetos de manera flexible, venir con un conjunto de bibliotecas que fueran utilizables, y permitir que el c\xc3\xb3digo (y cualquier recurso necesitado por el c\xc3\xb3digo) pudiera ser empaquetado en un formato multiplataforma._NEWLINE_Cox y Love luego fundaron una nueva empresa, Productivity Products International (PPI), para comercializar su producto, el cual era un compilador de Objective-C con un conjunto de bibliotecas potentes._NEWLINE_En 1986, Cox public\xc3\xb3 la principal descripci\xc3\xb3n de Objective-C en su forma original en el libro Object-Oriented Programming, An Evolutionary Approach. Aunque \xc3\xa9l fue cuidadoso en resaltar que hay muchos problemas de reutilizaci\xc3\xb3n que no dependen del lenguaje, Objective-C frecuentemente fue comparado detalladamente con otros lenguajes.\n_START_SECTION_\nPopularizaci\xc3\xb3n mediante NeXT\n_START_PARAGRAPH_\nEn 1998, NeXT licenci\xc3\xb3 el Objective-C de StepStone (el nuevo nombre de PPI, el due\xc3\xb1o de la marca Objective-C) y extendi\xc3\xb3 el compilador GCC para dar soporte a Objective-C, al mismo tiempo que desarroll\xc3\xb3 las librer\xc3\xadas AppKit y Foundation Kit sobre las que se basaron la interfaz de usuario y la interfaz de creaci\xc3\xb3n de NeXTstep. Mientras que las estaciones de trabajo de NeXT no consiguieron hacer un gran impacto en el mercado, las herramientas fueron ampliamente alabadas en la industria. Esto llev\xc3\xb3 a NeXT a abandonar la producci\xc3\xb3n de hardware y enfocarse en las herramientas de software, vendiendo NeXTstep (y OpenStep) como una plataforma para la programaci\xc3\xb3n a medida._NEWLINE_El trabajo para extender GCC fue liderado por Steve Naroff, que se uni\xc3\xb3 a NeXT proveniente de StepStone. Los cambios del compilador fueron puestos a disposici\xc3\xb3n bajo t\xc3\xa9rminos de licencia GPL, pero no las librer\xc3\xadas de tiempo de ejecuci\xc3\xb3n, dejando la contribuci\xc3\xb3n de c\xc3\xb3digo abierto inutilizable para el p\xc3\xbablico general. Esto llev\xc3\xb3 a que otras compa\xc3\xb1\xc3\xadas desarrollaran esas librer\xc3\xadas bajo licencias de c\xc3\xb3digo abierto. M\xc3\xa1s tarde, Steve Naroff fue tambi\xc3\xa9n un colaborador principal al trabajo de Apple de construir la interfaz de Objective-C Clang._NEWLINE_El proyecto GNU comenz\xc3\xb3 a trabajar en su implementaci\xc3\xb3n de Cocoa como software libre, llamado GNUstep y basado en el est\xc3\xa1ndar de OpenStep.\xe2\x80\x8b Dennis Glatting escribi\xc3\xb3 el primer sistema en tiempo de ejecuci\xc3\xb3n de GNU Objective-C en 1992. El sistema GNU Objective-C, que ha sido usado desde 1993, es uno de los desarrollados por Kresten Krab Thorup cuando era un estudiante universitario en Dinamarca. Thorup tambi\xc3\xa9n trabaj\xc3\xb3 en NeXT desde 1993 hasta 1997.\n_START_SECTION_\nDesarrollo de Apple y Swift\n_START_PARAGRAPH_\nTras adquirir NeXT en 1996, Apple emple\xc3\xb3 OpenStep en su nuevo sistema operativo, Mac OS X. Este inclu\xc3\xada Objective-C y la herramienta de desarrollo basada en Objective-C de NeXT, Project Builder (que luego se ha expandido y ahora se conoce por Xcode), as\xc3\xad como la herramienta de dise\xc3\xb1o de interfaz, Interface Builder. La mayor\xc3\xada de la actual Cocoa API de Apple est\xc3\xa1 basada en objetos de interfaz de OneStep, y es el entorno de desarrollo de Objective-C m\xc3\xa1s usado para desarrollo activo._NEWLINE_En la WWDC de 2014, Apple anunci\xc3\xb3 planes para reemplazar a Objective-C en el desarrollo de Cocoa por el nuevo lenguaje Swift, que es llamado "Objective-C sin la C".\n_START_SECTION_\nSintaxis\n_START_PARAGRAPH_\nObjective-C consiste en una capa muy fina situada por encima de C, y adem\xc3\xa1s es un estricto superconjunto de C. Esto es, es posible compilar cualquier programa escrito en C con un compilador de Objective-C, y tambi\xc3\xa9n puede incluir libremente c\xc3\xb3digo en C dentro de una clase de Objective-C._NEWLINE_Esto es, para escribir el programa cl\xc3\xa1sico "Hola Mundo" para correr en consola, se puede utilizar el siguiente c\xc3\xb3digo:_NEWLINE_#import <stdio.h>int main( int argc, const char *argv[] ) {_NEWLINE_    printf( "Hola Mundo\\n" );_NEWLINE_    return 0;}_NEWLINE_El c\xc3\xb3digo anterior se diferencia de un c\xc3\xb3digo en C com\xc3\xban por la primera instrucci\xc3\xb3n #import, que difiere del #include del C cl\xc3\xa1sico,  pero la funci\xc3\xb3n printf("") es puramente C. La funci\xc3\xb3n propia de Objective-C para imprimir una cadena de caracteres en consola es NSLog(@""); utiliz\xc3\xa1ndola, el c\xc3\xb3digo anterior quedar\xc3\xada de la siguiente manera:_NEWLINE_int main( int argc, const char *argv[] ) _NEWLINE_{_NEWLINE_    NSLog( @"Hola Mundo\\n" );_NEWLINE_    return 0;}_NEWLINE_La sintaxis de objetos de Objective-C deriva de Smalltalk. Toda la sintaxis para las operaciones no orientadas a objetos (incluyendo variables primitivas, pre-procesamiento, expresiones, declaraci\xc3\xb3n de funciones y llamadas a funciones) son id\xc3\xa9nticas a las de C, mientras que la sintaxis para las caracter\xc3\xadsticas orientadas a objetos es una implementaci\xc3\xb3n similar a la mensajer\xc3\xada de Smalltalk.\n_START_SECTION_\nMensajes\n_START_PARAGRAPH_\nEl modelo de programaci\xc3\xb3n orientada a objetos de Objective-C se basa en enviar mensajes a instancias de objetos. Esto es diferente al modelo de programaci\xc3\xb3n al estilo de Simula, utilizado por C++ y esta distinci\xc3\xb3n es sem\xc3\xa1nticamente importante. En Objective-C uno no llama a un m\xc3\xa9todo; uno env\xc3\xada un mensaje, y la diferencia entre ambos conceptos radica en c\xc3\xb3mo el c\xc3\xb3digo referido por el nombre del mensaje o m\xc3\xa9todo es ejecutado. En un lenguaje al estilo Simula, el nombre del m\xc3\xa9todo es en la mayor\xc3\xada de los casos atado a una secci\xc3\xb3n de c\xc3\xb3digo en la clase objetivo por el compilador, pero en Smalltalk y Objective-C, el mensaje sigue siendo simplemente un nombre, y es resuelto en tiempo de ejecuci\xc3\xb3n: el objeto receptor tiene la tarea de interpretar por s\xc3\xad mismo el mensaje. Una consecuencia de esto es que el mensaje del sistema que pasa no tiene chequeo de tipo: el objeto al cual es dirigido el mensaje (conocido como receptor) no est\xc3\xa1 inherentemente garantizado a responder a un mensaje, y si no lo hace, simplemente lo ignora y retorna un puntero nulo._NEWLINE_Enviar el mensaje method al objeto apuntado por el puntero obj requerir\xc3\xada el siguiente c\xc3\xb3digo en C++:_NEWLINE_obj->method(parameter);_NEWLINE_mientras que en Objective-C se escribir\xc3\xada como sigue:_NEWLINE_[obj method:parameter];_NEWLINE_Ambos estilos de programaci\xc3\xb3n poseen sus fortalezas y debilidades. La POO al estilo Simula permite herencia m\xc3\xbaltiple y r\xc3\xa1pida ejecuci\xc3\xb3n utilizando vinculaci\xc3\xb3n en tiempo de compilaci\xc3\xb3n siempre que sea posible, pero no soporta vinculaci\xc3\xb3n din\xc3\xa1mica por defecto. Esto fuerza a que todos los m\xc3\xa9todos posean su correspondiente implementaci\xc3\xb3n, al menos que sean virtuales (aun as\xc3\xad, se requiere una implementaci\xc3\xb3n del m\xc3\xa9todo para efectuar la llamada). La POO al estilo Smalltalk permite que los mensajes no posean implementaci\xc3\xb3n - por ejemplo, toda una colecci\xc3\xb3n de objetos pueden enviar un mensaje sin temor a producir errores en tiempo de ejecuci\xc3\xb3n. El env\xc3\xado de mensajes tampoco requiere que un objeto sea definido en tiempo de compilaci\xc3\xb3n. (Ver m\xc3\xa1s abajo la secci\xc3\xb3n tipado din\xc3\xa1mico) para m\xc3\xa1s ventajas de la ligadura din\xc3\xa1mica._NEWLINE_Sin embargo, se debe notar que debido a la sobrecarga de la interpretaci\xc3\xb3n de los mensajes, un mensaje en Objective-C toma, en el mejor de los casos, tres veces m\xc3\xa1s tiempo que una llamada a un m\xc3\xa9todo virtual en C++.\xe2\x80\x8b\n_START_SECTION_\nInterfaces e implementaciones\n_START_PARAGRAPH_\nObjective-C requiere que la interfaz e implementaci\xc3\xb3n de una clase est\xc3\xa9n en bloques de c\xc3\xb3digo separados. Por convenci\xc3\xb3n, la interfaz es puesta en un archivo cabecera y la implementaci\xc3\xb3n en un archivo de c\xc3\xb3digo; los archivos cabecera, que normalmente poseen el sufijo .h, son similares a los archivos cabeceras de C;  los archivos de implementaci\xc3\xb3n (m\xc3\xa9todo), que normalmente poseen el sufijo .m, pueden ser muy similares a los archivos de c\xc3\xb3digo de C.\n_START_SECTION_\nInterfaz\n_START_PARAGRAPH_\nLa interfaz de la clase es usualmente definida en el archivo cabecera. Una convenci\xc3\xb3n com\xc3\xban consiste en nombrar al archivo cabecera con el mismo nombre de la clase. La interfaz para la clase Clase deber\xc3\xada, as\xc3\xad, ser encontrada en el archivo Clase.h._NEWLINE_La declaraci\xc3\xb3n de la interfaz de la forma:_NEWLINE_@interface classname : superclassname _NEWLINE_{_NEWLINE_    // instance variables}+classMethod1;+(return_type)classMethod2;+(return_type)classMethod3:(param1_type)parameter_varName;-(return_type)instanceMethod1:(param1_type)param1_varName :(param2_type)param2_varName;-(return_type)instanceMethod2WithParameter:(param1_type)param1_varName andOtherParameter:(param2_type)param2_varName;@end_NEWLINE_Los signos m\xc3\xa1s denotan m\xc3\xa9todos de clase, los signos menos denotan m\xc3\xa9todos de instancia. Los m\xc3\xa9todos de clase no tienen acceso a las variables de la instancia._NEWLINE_Si usted viene de C++, el c\xc3\xb3digo anterior es equivalente a algo como esto:_NEWLINE_class classname : superclassname _NEWLINE_{_NEWLINE_  public:_NEWLINE_    // instance variables_NEWLINE_    _NEWLINE_    // Class (static) functions_NEWLINE_    static void* classMethod1();_NEWLINE_    static return_type classMethod2();_NEWLINE_    static return_type classMethod3(param1_type parameter_varName);_NEWLINE_    _NEWLINE_    // Instance (member) functions_NEWLINE_    return_type instanceMethod1(param1_type param1_varName, param2_type param2_varName);_NEWLINE_   return_type instanceMethod2WithParameter(param1_type param1_varName, param2_type param2_varName = default);};_NEWLINE_Note que instanceMethod2WithParameter demuestra la capacidad de nombrado de par\xc3\xa1metro de Objective-C para la cual no existe equivalente directo en C/C++._NEWLINE_Los tipos de retorno pueden ser cualquier tipo est\xc3\xa1ndar de C, un puntero a un objeto gen\xc3\xa9rico de Objective-C, o un puntero a un tipo espec\xc3\xadfico as\xc3\xad como NSArray *, NSImage *, o NSString *. El tipo de retorno por defecto es el tipo gen\xc3\xa9rico id de Objective-C._NEWLINE_Los argumentos de los m\xc3\xa9todos comienzan con dos puntos seguidos por el tipo de argumento esperado en los par\xc3\xa9ntesis seguido por el nombre del argumento. En algunos casos (por ej. cuando se escriben APIs de sistema) es \xc3\xbatil agregar un texto descriptivo antes de cada par\xc3\xa1metro._NEWLINE_-(void) setRangeStart:(int)start End:(int)end;-(void) importDocumentWithName:(NSString *)name withSpecifiedPreferences:(Preferences *)prefs beforePage:(int)insertPage;\n_START_SECTION_\nImplementaci\xc3\xb3n\n_START_PARAGRAPH_\nLa interfaz \xc3\xbanicamente declara la interfaz de la clase y no los m\xc3\xa9todos en s\xc3\xad; el c\xc3\xb3digo real es escrito en la implementaci\xc3\xb3n. Los archivos de implementaci\xc3\xb3n (m\xc3\xa9todos) normalmente poseen la extensi\xc3\xb3n .m._NEWLINE_@implementation classname+classMethod {_NEWLINE_    // implementation}-instanceMethod {_NEWLINE_    // implementation}@end_NEWLINE_Los m\xc3\xa9todos son escritos con sus declaraciones de interfaz. Comparando Objective-C y C:_NEWLINE_-(int)method:(int)i _NEWLINE_{_NEWLINE_    return [self square_root: i];}_NEWLINE_int function(int i) _NEWLINE_{_NEWLINE_    return square_root(i);}_NEWLINE_La sintaxis admite pseudo-nombrado de argumentos._NEWLINE_-(int)changeColorToRed:(float)red green:(float)green blue:(float)blue[myColor changeColorToRed:5.0 green:2.0 blue:6.0];_NEWLINE_La representaci\xc3\xb3n interna de \xc3\xa9ste m\xc3\xa9todo var\xc3\xada entre diferentes implementaciones de Objective-C. Si myColor es de la clase Color, internamente, la instancia del m\xc3\xa9todo -changeColorToRed:green:blue: podr\xc3\xada ser etiquetada como _i_Color_changeColorToRed_green_blue. La i hace referencia a una instancia de m\xc3\xa9todo, acompa\xc3\xb1ado por los nombres de la clase y el m\xc3\xa9todo, y los dos puntos son reemplazados por guiones bajos. Como el orden de los par\xc3\xa1metros es parte del nombre del m\xc3\xa9todo, \xc3\xa9ste no puede ser cambiado para adaptarse al estilo de codificaci\xc3\xb3n._NEWLINE_De todos modos, los nombres internos de las funciones son raramente utilizadas de manera directa, y generalmente los mensajes son convertidos a llamadas de funciones definidas en la librer\xc3\xada en tiempo de ejecuci\xc3\xb3n de Objective-C \xe2\x80\x93 el m\xc3\xa9todo que ser\xc3\xa1 llamado no es necesariamente conocido en tiempo de vinculaci\xc3\xb3n: la clase del receptor (el objeto que envi\xc3\xb3 el mensaje) no necesita conocerlo hasta el tiempo de ejecuci\xc3\xb3n.\n_START_SECTION_\nInstanciaci\xc3\xb3n\n_START_PARAGRAPH_\nUna vez que una clase es escrita en Objective-C, puede ser instanciada. Esto se lleva a cabo primeramente alojando la memoria para el nuevo objeto y luego inicializ\xc3\xa1ndolo. Un objeto no es completamente funcional hasta que ambos pasos sean completados. Esos pasos t\xc3\xadpicamente se logran con una simple l\xc3\xadnea de c\xc3\xb3digo:_NEWLINE_MyObject * o = [[MyObject alloc] init];_NEWLINE_La llamada a alloc aloja la memoria suficiente para mantener todas las variables de instancia para un objeto, y la llamada a init puede ser anulada para establecer las variables de instancia con valores espec\xc3\xadficos al momento de su creaci\xc3\xb3n. El m\xc3\xa9todo init es escrito a menudo de la siguiente manera:_NEWLINE_-(id) init _NEWLINE_{_NEWLINE_    self = [super init];_NEWLINE_    if (self) _NEWLINE_    {_NEWLINE_        ivar1 = \'\'\'value1\'\'\';_NEWLINE_        ivar2 = value2;_NEWLINE_        ._NEWLINE_        ._NEWLINE_        ._NEWLINE_    }_NEWLINE_    return self;}\n_START_SECTION_\nProtocolos\n_START_PARAGRAPH_\nObjective-C fue extendido en NeXT para introducir el concepto de herencia m\xc3\xbaltiple de la especificaci\xc3\xb3n, pero no la implementaci\xc3\xb3n, a trav\xc3\xa9s de la introducci\xc3\xb3n de protocolos. Este es un modelo viable, ya sea como una clase base abstracta multi-heredada en C++, o como una "interfaz" (como en Java o C#). Objective-C hace uso de protocolos ad-hoc, llamados protocolos informales, y el compilador debe cumplir los llamados protocolos formales.\n_START_SECTION_\nTipado din\xc3\xa1mico\n_START_PARAGRAPH_\nObjective-C, al igual que Smalltalk, puede usar tipado din\xc3\xa1mico: un objeto puede recibir un mensaje que no est\xc3\xa1 especificado en su interfaz. Esto se permite para incrementar la flexibilidad, ya que permite a un objeto "capturar" un mensaje y enviarlo a otro objeto diferente que pueda responder a ese mensaje apropiadamente, o del mismo modo reenviar el mensaje a otro objeto. Este comportamiento es conocido como reenv\xc3\xado de mensajes o delegaci\xc3\xb3n (ver m\xc3\xa1s abajo). Alternativamente, un manejo de error puede ser usado en caso de que el mensaje no pueda ser reenviado. Si un objeto no reenv\xc3\xada un mensaje, lo responde o maneja un error entonces el sistema generar\xc3\xa1 una excepci\xc3\xb3n en tiempo de ejecuci\xc3\xb3n. Si los mensajes son enviados a nil (el puntero de objetos nulo), ser\xc3\xa1n ignorados silenciosamente o elevar\xc3\xa1n una excepci\xc3\xb3n gen\xc3\xa9rica, dependiendo de las opciones del compilador._NEWLINE_La informaci\xc3\xb3n tipada est\xc3\xa1ticamente puede ser a\xc3\xb1adida opcionalmente a variables. Esta informaci\xc3\xb3n es luego comprobada a la hora de compilar. En las siguientes cuatro declaraciones se proveen tipos de informaci\xc3\xb3n crecientemente espec\xc3\xadficos. Estas declaraciones son equivalentes en el tiempo de ejecuci\xc3\xb3n, pero la informaci\xc3\xb3n adicional permite al compilador el avisar al programador si el argumento pasado no encaja con el tipo especificado._NEWLINE_- (void)setMyValue:(id)foo;_NEWLINE_En la declaraci\xc3\xb3n anterior, foo puede ser de cualquier clase._NEWLINE_- (void)setMyValue:(id<NSCopying>)foo;_NEWLINE_En la declaraci\xc3\xb3n anterior, foo puede ser una instancia de cualquier clase que satisfaga al protocolo NSCopying._NEWLINE_- (void)setMyValue:(NSNumber *)foo;_NEWLINE_En la declaraci\xc3\xb3n anterior, foo debe ser una instancia de la clase NSNumber._NEWLINE_- (void)setMyValue:(NSNumber<NSCopying> *)foo;_NEWLINE_En la declaraci\xc3\xb3n anterior, foo debe ser una instancia de la clase NSNumber, y debe satisfacer al protocolo NSCopying.\n_START_SECTION_\nNotas\n_START_PARAGRAPH_\nCuando se compila con gcc, el compilador reporta:_NEWLINE__NEWLINE_$ gcc -x objective-c -Wno-import Forwarder.m Recipient.m main.m -lobjc_NEWLINE_main.m: In function `main\':_NEWLINE_main.m:12: warning: `Forwarder\' no responde a `hola\'_NEWLINE_$_NEWLINE_El compilador reporta lo comentando antes, que Forwarder no responde a mensajes hola. En esta circunstancia, es seguro ignorar el aviso ya que el reenv\xc3\xado fue implementando. La ejecuci\xc3\xb3n del programa produce esta salida:_NEWLINE__NEWLINE_& ./a.out_NEWLINE_El receptor dice hola!\n_START_SECTION_\nObjective-C 2.0\n_START_PARAGRAPH_\nEn la Worldwide Developers Conference de 2006, Apple anunci\xc3\xb3 el lanzamiento de "Objective-C 2.0", una revisi\xc3\xb3n del lenguaje Objective-C para incluir "una recolecci\xc3\xb3n de basura moderna, mejoras de sintaxis,\xe2\x80\x8b  perfeccionamiento de la ejecuci\xc3\xb3n\xe2\x80\x8b  y soporte para 64 bits". Mac OS X v10.5, lanzado en octubre de 2007, inclu\xc3\xada un compilador de Objective-C 2.0. GCC 4.6 soporta muchas aplicaciones nuevas de Objective-C, como las propiedades declaradas y sintetizadas, sintaxis de puntos, enumeraci\xc3\xb3n r\xc3\xa1pida, m\xc3\xa9todos de protocolo opcionales, atributos de m\xc3\xa9todo/protocolo/clase, extensiones de clase y una nueva API de GNUnn Objective-C.\xe2\x80\x8b\n_START_SECTION_\nRecolecci\xc3\xb3n de basura\n_START_PARAGRAPH_\nObjective 2.0 contaba con un recolector de basura conservativo opcional. Cuando se ejecutaba en modo de retrocompatibilidad, cambiaba las operaciones de conteo de referencias como "retener" y "liberar" en NOPs (No operaciones, instrucci\xc3\xb3n de ensamblador que indica que el procesador no tiene que hacer nada). Todos los objetos eran sometidos al recolector de basura cuando la recolecci\xc3\xb3n de basura estaba habilitada. Los punteros de C pod\xc3\xadan ser cualificados con "__strong" para provocar la intercepci\xc3\xb3n de escritura del compilador y as\xc3\xad participar en la recolecci\xc3\xb3n de basura.\xe2\x80\x8b Un subsistema d\xc3\xa9bil de puesta a cero tambi\xc3\xa9n era provisto de tal manera que los punteros marcados con "__weak" eran puestos a cero cuando el objeto (o m\xc3\xa1s f\xc3\xa1cilmente, la memoria del recolector de basura) es recolectado. El recolector de basura no exist\xc3\xada en la implementaci\xc3\xb3n de Objective-C 2.0 de iOS.\xe2\x80\x8b La recolecci\xc3\xb3n de basura en Objective-C se ejecuta en un hilo de baja prioridad y puede detener eventos del usuario, con la intenci\xc3\xb3n de mantener la experiencia del usuario receptiva.\xe2\x80\x8b _NEWLINE_La recolecci\xc3\xb3n de basura nunca estuvo disponible en iOS debido a problemas de rendimiento. Fue despreciado en la versi\xc3\xb3n 10.8 de OS X en favor del Conteo de Referencias Autom\xc3\xa1tico (en ingl\xc3\xa9s: Automatic Reference Counting, ARC) y est\xc3\xa1 programado que se elimine en una futura versi\xc3\xb3n de OS X.\xe2\x80\x8b Objective-C en iOS 7 ejecutado en ARM64 usa 19 bits de una palabra de 64 bits para almacenar el conteo de referencias, como una forma de puntero etiquetado.\xe2\x80\x8b\xe2\x80\x8b\n_START_SECTION_\nPropiedades\n_START_PARAGRAPH_\nObjective 2.0 introduce una nueva sintaxis para declarar variables de instancia como propiedades, con atributos opcionales para configurar la generaci\xc3\xb3n de m\xc3\xa9todos de acceso. Las propiedades son, en cierto sentido, variables de instancia p\xc3\xbablicas; esto es, declarar una variable de instancia como una propiedad provee a clases externas de acceso (posiblemente limitado, como por ejemplo s\xc3\xb3lo lectura) a esa propiedad. Una propiedad puede ser declarada como "readonly" (solo lectura) y puede ser provista de sem\xc3\xa1ntica de almacenamiento como "assign" (asignar), "copy" (copiar) o "retain" (retener). Por defecto, las propiedades son consideradas at\xc3\xb3micas, que resulta en un seguro para prevenir a m\xc3\xbaltiples hilos que accedan a ella al mismo tiempo. Una propiedad puede ser declarada como "nonatomic" (no at\xc3\xb3mica), que elimina este seguro._NEWLINE_@interface Persona : NSObject {_NEWLINE_ @public_NEWLINE_ NSString *nombre;_NEWLINE_ @private_NEWLINE_ int edad;}@property(copy) NSString *nombre;@property(readonly) int edad;-(id)iniciarConEdad:(int)edad;@end_NEWLINE_Las propiedades son implementadas mediante la palabra clave @synthesize, que genera los m\xc3\xa9todos getter (y setter, si no son de s\xc3\xb3lo lectura) de acuerdo a la declaraci\xc3\xb3n de la propiedad. Alternativamente, los m\xc3\xa9todos getter y setter deben ser implementados expl\xc3\xadcitamente, o la palabra clave @dynamic puede ser usada para indicar que los m\xc3\xa9todos de acceso deben ser provistos por otros medios. Cuando se compila usando Clang 3.1 o superior, todas las propiedades que no est\xc3\xa9n expl\xc3\xadcitamente declaradas con @dynamic, no est\xc3\xa9n marcadas readonly o no tengan los m\xc3\xa9todos completos implementados por el usuario getter y setter, ser\xc3\xa1n autom\xc3\xa1ticamente declaradas @synthesize de manera impl\xc3\xadcita._NEWLINE_@implementation Persona@synthesize nombre;-(id)iniciarConEdad:(int)edadInicial {_NEWLINE_ self = [super inicial];_NEWLINE_ if (self) {_NEWLINE_ edad = edadInicial; // NOTA: asignaci\xc3\xb3n directo de la variable de instancia, no propiedad setter_NEWLINE_ }_NEWLINE_ return self;}-(int)edad {_NEWLINE_ return edad;}@end_NEWLINE_Las propiedades pueden ser accedidas usando la sintaxis tradicional de paso de mensajes, notaci\xc3\xb3 por puntos o, en Codificaci\xc3\xb3n Key-Value, mediante los m\xc3\xa9todos valueForKey:/setValue:forKey._NEWLINE_Persona *unaPersona = [[Persona alloc] iniciarConEdad: 53];unaPersona.nombre = @"Steve"; // NOTA: la notaci\xc3\xb3n por puntos, usa el setter sintetizado,_NEWLINE_ // equivalente a [unaPersona setNombre: @"Steve"];NSLog(@"Acceso por mensaje (%@), notaci\xc3\xb3n por puntos(%@),nombre de propiedad(%@) y acceso directo a la variabled e instancia (%@)",_NEWLINE_ [unaPersona nombre], unaPersona.nombre, [unaPersona valueForKey:@"nombre"], unaPersona->nombre);_NEWLINE_Para que el uso de notaci\xc3\xb3n por puntos invoque a las propiedades de acceso en un m\xc3\xa9todo de instancia, la palabra clave "self" debe ser usada:_NEWLINE_-(void) presentarmeConPropiedades:(BOOL)useGetter {_NEWLINE_ NSLog(@"Hola, mi nombre es %@.", (useGetter ? self.nombre : nombre));// NOTA: getter vs. acceso ivar}_NEWLINE_Una clase o las propiedades de protocolo pueden ser introspeccionadas din\xc3\xa1micamente._NEWLINE_int i;int contadorPropiedades = 0;objc_propiedad_t *listaPropiedades = clase_copiarListaPropiedades([unaPersona class], &contadorPropiedades);for (i = 0; i < contadorPropiedades; i++) {_NEWLINE_ objc_propiedad_t *estaPropiedad = listaPropiedades + i;_NEWLINE_ const char* nombrePropiedad = propiedad_getNombre(*estaPropiedad);_NEWLINE_ NSLog(@"Persona tiene una propiedad: \'%s\'", nombrePropiedad);}\n_START_SECTION_\nEnumeraci\xc3\xb3n r\xc3\xa1pida\n_START_PARAGRAPH_\nEn lugar de usar un objeto NSEnumerator o indicar la iteraci\xc3\xb3n a lo largo de una colecci\xc3\xb3n, Objective-C 2.0 ofrece la sintaxis de enumeraci\xc3\xb3n r\xc3\xa1pida. En Objective-C 2.0, los siguientes bucles son funcionalmente equivalentes, pero tienen diferentes caracter\xc3\xadsticas de rendimiento._NEWLINE_// Usando NSEnumeratorNSEnumerator *enumerador = [laGente objectEnumerator];Persona *p;while ((p = [enumerador nextObject]) != nil) {_NEWLINE_ NSLog(@"%@ tiene %i a\xc3\xb1os.", [p nombre], [p edad]);}_NEWLINE_// Usando \xc3\xadndicesfor (int i = 0; i < [laGente count]; i++) {_NEWLINE_ Persona *p = [laGente objectAtIndex:i];_NEWLINE_ NSLog(@"%@ tiene %i a\xc3\xb1os.", [p nombre], [p edad]);}_NEWLINE_// Using enumeraci\xc3\xb3n r\xc3\xa1pidafor (Persona *p in laGente) {_NEWLINE_ NSLog(@"%@ tiene %i a\xc3\xb1os.", [p nombre], [p edad]);}_NEWLINE_La enumeraci\xc3\xb3n r\xc3\xa1pida genera c\xc3\xb3digo m\xc3\xa1s eficiente que la enumeraci\xc3\xb3n est\xc3\xa1ndar porque las llamadas a los m\xc3\xa9todos para enumerar objetos son reemplazadas por aritm\xc3\xa9tica de punteros usando el protocolo NSFastEnumeration.\n_START_SECTION_\nExtensi\xc3\xb3n de clases\n_START_PARAGRAPH_\nUna extensi\xc3\xb3n de clase tiene el mismo sintaxis que una declaraci\xc3\xb3n de categor\xc3\xada sin nombre de categor\xc3\xada y los m\xc3\xa9todos y propiedades declarados en ella son a\xc3\xb1adidos directamente a la clase main. Es sobre todo usado como una alternativa a una categor\xc3\xada el a\xc3\xb1adir m\xc3\xa9todos a una clase sin declararlos en las cabeceras p\xc3\xbablicas, con la ventaja de que para las extensiones de clase el compilador comprueba que todos los m\xc3\xa9todos declarados privadamente son implementados realmente.\xe2\x80\x8b\n_START_SECTION_\nBlocks\n_START_PARAGRAPH_\nBlocks es una extensi\xc3\xb3n no est\xc3\xa1ndar para Objective-C (as\xc3\xad como para C y C++) que usa una sintaxis especial para crear clausuras. Blocks s\xc3\xb3lo est\xc3\xa1 soportado en Mac OS X 10.6 "Snow Leopard" o superior y en iOS 4 o superior, as\xc3\xad como en GNUstep con libobjc2 1.7 y compilado con Clang 3.1 o superior.\xe2\x80\x8b _NEWLINE_#include <stdio.h>#include <Block.h>typedef int (^IntBlock)();IntBlock MakeCounter(int start, int increment) {_NEWLINE___block int i = start;_NEWLINE__NEWLINE_return Block_copy( ^ {_NEWLINE_int ret = i;_NEWLINE_i += increment;_NEWLINE_return ret;_NEWLINE_});_NEWLINE__NEWLINE_}int main(void) {_NEWLINE_IntBlock mycounter = MakeCounter(5, 2);_NEWLINE_printf("First call: %d\\n", mycounter());_NEWLINE_printf("Second call: %d\\n", mycounter());_NEWLINE_printf("Third call: %d\\n", mycounter());_NEWLINE__NEWLINE_/* because it was copied, it must also be released */_NEWLINE_Block_release(mycounter);_NEWLINE__NEWLINE_return 0;}/* Output:First call: 5Second call: 7Third call: 9*/\n_START_SECTION_\nAutomatic Reference Counting\n_START_PARAGRAPH_\nAutomatic Reference Counting (Conteo Autom\xc3\xa1tico de Referencias, ARC) es una caracter\xc3\xadstica del tiempo de compilaci\xc3\xb3n que elimina la necesidad de que los programadores tengan que guardar manualmente cuentas usando retain y release.\xe2\x80\x8b Al contrario que el recolector de basura, que funciona en tiempo de ejecuci\xc3\xb3n, el ARC elimina la sobrecarga de un proceso separado al gestionar la retenci\xc3\xb3n de las cuentas. El ARC y el manejo manual de memoria no son mutualmente excluyentes; los programadores pueden continuar usando c\xc3\xb3digo no ARC en proyectos que tienen el ARC activado mediante la desactivaci\xc3\xb3n del ARC para c\xc3\xb3digos fuente individuales. Xcode tambi\xc3\xa9n puede tratar de actualizar autom\xc3\xa1ticamente un proyecto a ARC.\n_START_SECTION_\nLiterales\n_START_PARAGRAPH_\nLos entornos de ejecuci\xc3\xb3n NeXT y Apple Obj-C incluyeron hace tiempo un atajo para crear nuevas cadenas, usando la sintaxis literal @"una nueva cadena" y tambi\xc3\xa9n desecharon las constantes de CoreFoundation kCFBooleanTrue y kCFBooleanFalse por la variable NSNUmber con valores booleanos. Al usar este formato se libera al programador de usar el m\xc3\xa1s largo initWithString o m\xc3\xa9todos similares al hacer ciertas operaciones._NEWLINE_Cuando se usa el compilador de Apple LLVM 4.0 o superior, vectores, diccionarios y n\xc3\xbameros (las clases NSAray, NSDictionary y NSNumber) pueden ser tambi\xc3\xa9n creados usando sintaxis literal en lugar de m\xc3\xa9todos.\xe2\x80\x8b  La sintaxis literal usa el s\xc3\xadmbolo @ combinado con [], {} o () para crear las clases mencionadas anteriormente, respectivamente.\xe2\x80\x8b _NEWLINE_Ejemplo sin literales:_NEWLINE_NSArray *miVector = [NSArray arrayConObjectos:objeto1,objeto2,objeto3,nil];NSDictionary *miDiccionario1 = [NSDictionary diccionarioConObjeto:unObjeto forKey:@"llave"];NSDictionary *miDiccionario2 = [NSDictionary diccionarioConObjetosYLlaves:objeto1, llave1, objeto2, llave2, nil];NSNumber *miNumero = [NSNumber numeroConInt:miInt];NSNumber *miNumeroSuma = [NSNumber numeroConInt:(2 + 3)];NSNumber *miNumeroBooleano = [NSNumber numeroConBooleano:YES];_NEWLINE_Ejemplo con literales:_NEWLINE_NSArray *myVector = @[ objeto1, objeto2, objeto3 ];NSDictionary *miDiccionario1 = { @"llave" : unObjeto };NSDictionary *miDiccionario2 = { llave1: objeto1, llave2: objeto2 };NSNumber *miNumero = @{miInt};NSNumber *miNumeroSuma = @{2+3};NSNumber *miNumeroBooleano = @YES;_NEWLINE_Sin embargo, al contrario que las cadenas literales que se compilan como constantes en el ejecutable, estos literales se compilan como c\xc3\xb3digo equivalente a las llamadas a m\xc3\xa9todos mencionadas arriba. En particular, bajo manejo manual del conteo de referencia de memoria, estos objetos son autoliberados, lo que requiere especial cuidado cuando por ejemplo son usados con variables de funciones est\xc3\xa1ticas o otros tipos de variables globales.\n_START_SECTION_\nSub\xc3\xadndices\n_START_PARAGRAPH_\nCuando se usa el compilador de Apple LLVM 4.0 o superior, vectores y diccionarios (las clases NSArray y NSDictionary) pueden ser manipuladas usando sub\xc3\xadndices.\xe2\x80\x8b Los sub\xc3\xadndices se pueden usar para recuperar valores de \xc3\xadndices (vectores) o llaves (diccionarios) y con objetos mutables tambi\xc3\xa9n puede user para fijar objetos a \xc3\xadndices o llaves. En el c\xc3\xb3digo, los sub\xc3\xadndices son representados usando corchetes [ ].\xe2\x80\x8b_NEWLINE_Ejemplos sin sub\xc3\xadndices:_NEWLINE_id objeto1 = [unVector objectAtIndex:0];id objeto2 = [unDiccionario objectForKey:@"llave"];[unVectorMutable replaceObjectAtIndex:0 withObject:objeto3];[unDiccionarioMutable setObject:objeto4 forKey:@"llave"];_NEWLINE_Ejemplos con sub\xc3\xadndices:_NEWLINE_id objeto1 = unVector[0];id objeto2 = unDiccionario[@"llave"];unVectorMutable[0] = objeto3;unDiccionarioMutable[@"llave"] = objeto4;\n_START_SECTION_\nSintaxis de Objective-C "Moderna" (1997)\n_START_PARAGRAPH_\nTras la compra de NeXT por parte de Apple, se hicieron varios intentos para asemejar m\xc3\xa1s el lenguaje con respecto a otros lenguajes existentes. Uno de estos intentos fue la introducci\xc3\xb3n de lo que se denomin\xc3\xb3 en su momento "Sintaxis moderna" para Objective-C (en oposici\xc3\xb3n a la existente, sintaxis "cl\xc3\xa1sica"). No hab\xc3\xada cambios en el comportamiento real, simplemente era una sintaxis alternativa._NEWLINE_La invocaci\xc3\xb3n a un m\xc3\xa9todo se hac\xc3\xada de este modo:_NEWLINE_objeto = (MiClase.alloc).init;objeto.primeraEtiq ( param1, param2 );_NEWLINE_Y paso a escribirse de este otro modo:_NEWLINE_objeto = [[MiClase alloc] init];[objeto primeraEtiq: param1 segundaEtiq: param2];_NEWLINE_Similarmente, las declaraciones pasaron de ser as\xc3\xad:_NEWLINE_-(void) primeraEtiq ( int param1, int param2 );_NEWLINE_a ser as\xc3\xad:_NEWLINE_-(void) primeraEtiq: (int)param1 segundaEtiq: (int)param2;_NEWLINE_Esta sintaxis "moderna" no est\xc3\xa1 soportada en dialectos actuales de Objective-C.\n_START_SECTION_\nPortable Object Compiler\n_START_PARAGRAPH_\nAdem\xc3\xa1s de las implementaciones de GCC/NeXT/Apple, que a\xc3\xb1adieron varias extensiones a la implementaci\xc3\xb3n original de Stepstone, tambi\xc3\xa9n existe otra implementaci\xc3\xb3n libre y abierta de Objective-C llamada Protable Object Compiler.\xe2\x80\x8b  El conjunto de extensiones implementadas por el Portable Object Compiler difiere de las implementaciones GCC/NeXT/Apple; en particular, incluye blocks similares a los de Smalltalk para Objective-C, mientras que carece de protocolos y categor\xc3\xadas, dos caracter\xc3\xadsticas usadas ampliamente en OpenStep y sus derivados. En conjunto, POC representa una etapa vieja, pre-NeXT, de la evoluci\xc3\xb3n del lenguaje, simplemente conforme al libro de 1991 de Brad Cox._NEWLINE_Tambi\xc3\xa9n incluye una librer\xc3\xada de tiempo de ejecuci\xc3\xb3n llamada ObjectPak, que est\xc3\xa1 basada en la librer\xc3\xada original ICPak101 de Cox (que a su vez deriva de la librer\xc3\xada de clases Smalltalk-80) y es radicalmente diferente a la de OneStep FoundationKit.\n_START_SECTION_\nGEOS Objective-C\n_START_PARAGRAPH_\nEl sistema PC GEOS usaba un lenguaje de programaci\xc3\xb3n conocido como GEOS Objective-C o goc;\xe2\x80\x8b a pesar de su similar nombre, los dos lenguajes son similares en un concepto global y por el uso de palabras clave precedidas por el signo @.\n_START_SECTION_\nClang\n_START_PARAGRAPH_\nLa suite de compiladores Clang, parte del proyecto LLVM, implementa Objective-C as\xc3\xad como otros lenguajes.'