Objective-C ++ Edita
Objective-C ++ és una variant de l’llenguatge acceptada per la interfície de l’GNU Compiler Collection i Clang, que pot compilar arxius de codi font que usin una combinació de sintaxi de C ++ i Objective-C. Objective-C ++ afegeix a C ++ les extensions que Objective-C s’afegeix a C. Com que no es fa res per unificar la semàntica darrere de les característiques de diversos llenguatges, hi ha certes restriccions:
- Una classe de C ++ no pot derivar d’una classe de Objective-C i viceversa.
- Espais de noms de C ++ no poden ser declarats dins d’una declaració d’Objective-C.
- Les declaracions de Objective -C han d’aparèixer de manera global, no dins d’una declaració de C ++.
- Les classes de Objective-C no poden tenir instàncies variables de classes de C ++ que no tinguin un constructor per defecte o que tinguin un o més mètodes virtuals, però els punters a objectes de C ++ poden ser usats com a instàncies variables sense restricció (s’assignen en el mètode -init).
- Les semàntiques “per valor” de C ++ no poden ser aplicades a objectes d’Objective-C, que només són accessibles mitjançant punters.
- Una declaració d’Objective-C no pot estar d’ Ntre d’una plantilla de declaració de C ++ i viceversa. No obstant això, els tipus d’Objective-C (com classname *) poden ser usats com a paràmetres de plantilles de C ++.
- El maneig d’excepcions de Objective-C i C ++ és diferent; cada llenguatge només pot gestionar excepcions pròpies. Això és mitigat en recents versions o bé reemplaçant completament les exceptiones de Objective-C per excepcions de C ++ (com fa Apple), o parcialment quan està enlacada la llibreria de Objective-C ++ (GNUstep libobjc2).
- Hi ha anar amb compte ja que les trucades a l’destructor de les excepcions en temps d’execució de Objective-C i C ++ no coincideixen (per exemple, un destructor de C ++ no serà cridat quan una excepció d’Objective-C surt de l’abast d’un objecte de C ++ ). Les noves versions de 64 bits solucionen això mitjançant la introducció d’interoperabilitat amb les excepcions de C ++ en aquest sentit.
- Els blocks de Objective-C i les lambdes de C ++ 11 són entitats diferents, però 1 block és generat transparentment en Mac OS X quan es passa un lambda on s’espera un bloc.
Objective-C 2.0Editar
a la Worldwide Developers Conference de 2006, Apple va anunciar el llançament de “Objective-C 2.0”, una revisió de l’llenguatge Objective-C per incloure “una recol·lecció d’escombraries moderna, millores de sintaxi, perfeccionament de l’execució i suport per a 64 bits”. Mac OS X 10.5, llançat a l’octubre de 2007, incloïa un compilador d’Objective-C 2.0. GCC 4.6 suporta moltes aplicacions noves de Objective-C, com les propietats declarades i sintetitzades, sintaxi de punts, enumeració ràpida, mètodes de protocol opcionals, atributs de mètode / protocol / classe, extensions de classe i una nova API de GNUnn Objective-C .
Recollida de basuraEditar
Objective 2.0 comptava amb un recol·lector d’escombraries conservatiu opcional. Quan s’executava en mode de retrocompatibilitat, canviava les operacions de recompte de referències com “retenir” i “alliberar” a NOPs (No operacions, instrucció d’assemblador que indica que el processador no ha de fer res). Tots els objectes eren sotmesos a l’recol·lector d’escombraries quan la recollida d’escombraries estava habilitada. Els punters de C podien ser qualificats amb “__strong” per provocar la intercepció d’escriptura de compilador i així participar en la recollida d’escombraries. Un subsistema feble de posada a zero també era proveït de tal manera que els punters marcats amb “__weak” eren posats a zero quan l’objecte (o més fàcilment, la memòria de l’recol·lector d’escombraries) és recol·lectat. El recol·lector d’escombraries no existia en la implementació d’Objective-C 2.0 de iOS. La recollida d’escombraries en Objective-C s’executa en un fil de baixa prioritat i pot aturar esdeveniments de l’usuari, amb la intenció de mantenir l’experiència de l’usuari receptiva.
La recollida d’escombraries mai va estar disponible en iOS causa de problemes de rendiment. Va ser menyspreat en la versió 10.8 d’OS X en favor de el Conteo de Referències Automàtic (en anglès: Automatic Reference Counting, ARC) i està programat que s’elimini en una futura versió d’OS X. Objective-C en iOS 7 executat en ARM64 fa servir 19 bits d’una paraula de 64 bits per emmagatzemar el recompte de referències, com una forma de punter etiquetatge.
PropiedadesEditar
Objective 2.0 introdueix una nova sintaxi per declarar variables d’instància com a propietats , amb atributs opcionals per configurar la generació de mètodes d’accés.Les propietats són, en cert sentit, variables d’instància públiques; és a dir, declarar una variable d’instància com una propietat proveeix a classes externes d’accés (possiblement limitat, com ara només lectura) a aquesta propietat. Una propietat pot ser declarada com “readonly” (només lectura) i pot ser proveïda de semàntica d’emmagatzematge com “assign” (assignar), “copy” (copiar) o “retain” (retenir). Per defecte, les propietats són considerades atòmiques, que resulta en una assegurança per prevenir a múltiples fils que hi accedeixin a el mateix temps. Una propietat pot ser declarada com “nonatomic” (no atòmica), que elimina aquesta assegurança.
@interface Persona : NSObject { @public NSString *nombre; @private int edad;}@property(copy) NSString *nombre;@property(readonly) int edad;-(id)iniciarConEdad:(int)edad;@end
Les propietats són implementades mitjançant la paraula clau @synthesize, que genera els mètodes getter (i setter, si no són de només lectura) d’acord amb la declaració de la propietat. Alternativament, els mètodes getter i setter han de ser implementats explícitament, o la paraula clau @dynamic pot ser usada per a indicar que els mètodes d’accés han de ser proveïts per altres mitjans. Quan es compila usant Clang 3.1 o superior, totes les propietats que no estiguin explícitament declarades amb @dynamic, no estiguin marcades readonly o no tinguin els mètodes complets implementats per l’usuari getter i setter, seran automàticament declarades @synthesize de manera implícita .
@implementation Persona@synthesize nombre;-(id)iniciarConEdad:(int)edadInicial { self = ; if (self) { edad = edadInicial; // NOTA: asignación directo de la variable de instancia, no propiedad setter } return self;}-(int)edad { return edad;}@end
Les propietats poden ser accedides fent servir la sintaxi tradicional de pas de missatges, notació per punts o, en Codificació Key- Value, mitjançant els mètodes valueForKey: / setValue:forKey.
Persona *unaPersona = iniciarConEdad: 53];unaPersona.nombre = @"Steve"; // NOTA: la notación por puntos, usa el setter sintetizado, // equivalente a ;NSLog(@"Acceso por mensaje (%@), notación por puntos(%@),nombre de propiedad(%@) y acceso directo a la variabled e instancia (%@)", , unaPersona.nombre, , unaPersona->nombre);
Perquè l’ús de notació per punts invoqui a les propietats d’accés en un mètode d’instància, la paraula clau “self” s’hauria d’utilitzar:
-(void) presentarmeConPropiedades:(BOOL)useGetter { NSLog(@"Hola, mi nombre es %@.", (useGetter ? self.nombre : nombre));// NOTA: getter vs. acceso ivar}
Una classe o les propietats de protocol poden ser introspeccionadas dinàmicament.
int i;int contadorPropiedades = 0;objc_propiedad_t *listaPropiedades = clase_copiarListaPropiedades(, &contadorPropiedades);for (i = 0; i < contadorPropiedades; i++) { objc_propiedad_t *estaPropiedad = listaPropiedades + i; const char* nombrePropiedad = propiedad_getNombre(*estaPropiedad); NSLog(@"Persona tiene una propiedad: '%s'", nombrePropiedad);}
Variables d’instància no frágilesEditar
Objective-C 2.0 proveeix de variables d’instància no fràgils suportades per l’entorn d’execució (per exemple, creant codi per a un Mac OS X de 64 bits així com codi per a tots els iOS). Sota l’entorn d’execució modern, una capa extra de biaix és afegida per instanciar variables d’accés, permetent l’enllaçador dinàmic ajustar el pla de instanciacions en temps d’execució. Aquesta propietat permet dues grans millores en el codi Objective-C:
- Elimina el problema de la fragilitat d’interfícies binàries – les superclasses poden canviar la seva mida sense afectar la compatibilitat binària.
- Permet que les variables d’instància que proveeixen retrocompatibilitat per a les propietats puguin ser sintetitzades en el temps d’execució sense que estiguin declarades en la interfície de la classe.
Enumeració rápidaEditar
En lloc d’utilitzar un objecte NSEnumerator o indicar la iteració al llarg d’una col·lecció, Objective-C 2.0 ofereix la sintaxi d’enumeració ràpida. En Objective-C 2.0, els següents bucles són funcionalment equivalents, però tenen diferents característiques de rendiment.
// Usando NSEnumeratorNSEnumerator *enumerador = ;Persona *p;while ((p = ) != nil) { NSLog(@"%@ tiene %i años.", , );}
// Usando índicesfor (int i = 0; i < ; i++) { Persona *p = ; NSLog(@"%@ tiene %i años.", , );}
// Using enumeración rápidafor (Persona *p in laGente) { NSLog(@"%@ tiene %i años.", , );}
l’enumeració ràpida genera codi més eficient que l’enumeració estàndard perquè les trucades als mètodes per enumerar objectes són reemplaçades per aritmètica de punters usant el protocol NSFastEnumeration.
extensió de clasesEditar
Una extensió de classe té el mateix sintaxi que una declaració de categoria sense nom de categoria i els mètodes i propietats declarats en ella són afegits directament a la classe main. És sobretot usat com una alternativa a una categoria el afegir mètodes a una classe sense declarar-los en les capçaleres públiques, amb l’avantatge que per a les extensions de classe el compilador comprova que tots els mètodes declarats privadament són implementats realment.
BlocksEditar
Blocks és una extensió no estàndard per Objective-C (així com per a C i C ++) que utilitza una sintaxi especial per crear clausures. Blocks només està suportat en Mac OS X 10.6 “Snow Leopard” o superior i en iOS 4 o superior, així com en GNUstep amb libobjc2 1.7 i compilat amb Clang 3.1 o superior.
#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("First call: %d\n", mycounter());printf("Second call: %d\n", mycounter());printf("Third call: %d\n", mycounter());/* because it was copied, it must also be released */Block_release(mycounter);return 0;}/* Output:First call: 5Second call: 7Third call: 9*/
Modern Objective-CEditar
Automatic Reference CountingEditar
Automatic Reference Counting (Conteo Automàtic de Referències, ARC) és una característica de el temps de compilació que elimina la necessitat que els programadors hagin de guardar manualment comptes usant retain i release. A l’contrari que el recol·lector d’escombraries, que funciona en temps d’execució, l’ARC elimina la sobrecàrrega d’un procés separat a l’gestionar la retenció dels comptes. El ARC i el maneig manual de memòria no són mútuament excloents; els programadors poden continuar fent servir codi no ARC en projectes que tenen l’ARC activat mitjançant la desactivació de l’ARC per codis font individuals. Xcode també pot tractar d’actualitzar automàticament un projecte a ARC.
LiteralesEditar
Els entorns d’execució NeXT i Apple Obj-C van incloure fa temps una drecera per crear noves cadenes, fent servir la sintaxi literal @"una nueva cadena" i també van rebutjar les constants de CoreFoundation kCFBooleanTrue i kCFBooleanFalse per la variable NSNUmber amb valors booleans. A l’usar aquest format s’allibera a l’programador d’usar el més llarg initWithString o mètodes similars a l’fer certes operacions.
Quan es fa servir el compilador d’Apple LLVM 4.0 o superior, vectors, diccionaris i nombres (les classes NSAray, NSDictionary i NSNumber) poden ser també creats usant sintaxi literal en lloc de mètodes. La sintaxi literal fa servir el símbol @ combinat amb , {} o () per crear les classes esmentades anteriorment, respectivament.
Exemple sense literals:
NSArray *miVector = ;NSDictionary *miDiccionario1 = ;NSDictionary *miDiccionario2 = ;NSNumber *miNumero = ;NSNumber *miNumeroSuma = ;NSNumber *miNumeroBooleano = ;
Exemple amb literals:
NSArray *myVector = @;NSDictionary *miDiccionario1 = { @"llave" : unObjeto };NSDictionary *miDiccionario2 = { llave1: objeto1, llave2: objeto2 };NSNumber *miNumero = @{miInt};NSNumber *miNumeroSuma = @{2+3};NSNumber *miNumeroBooleano = @YES;
No obstant això, a l’contrari que les cadenes literals que es compilen com constants en el programa, aquests literals es compilen com a codi equivalent a les trucades a mètodes esmentades a dalt. En particular, sota maneig manual de el recompte de referència de memòria, aquests objectes són autoliberados, el que requereix especial cura quan per exemple són usats amb variables de funcions estàtiques o altres tipus de variables globals.
SubíndicesEditar
Quan es fa servir el compilador d’Apple LLVM 4.0 o superior, vectors i diccionaris (les classes NSArray i NSDictionary) poden ser manipulades usant subíndexs. Els subíndexs es poden usar per a recuperar valors d’índexs (vectors) o claus (diccionaris) i amb objectes mutables també pot user per fixar objectes a índexs o claus. En el codi, els subíndexs són representats usant claudàtors .
Exemples sense subíndexs:
id objeto1 = ;id objeto2 = ;;;
Exemples amb subíndexs:
id objeto1 = unVector;id objeto2 = unDiccionario;unVectorMutable = objeto3;unDiccionarioMutable = objeto4;
Sintaxi de Objective-C “Moderna” (1997 ) Edita
Després de la compra de NeXT per part d’Apple, es van fer diversos intents per assemblar més el llenguatge respecte a altres llenguatges existents. Un d’aquests intents va ser la introducció del que es va denominar en el seu moment “Sintaxi moderna” per Objective-C (en oposició a l’existent, sintaxi “clàssica”). No hi havia canvis en el comportament real, simplement era una sintaxi alternativa.La invocació a un mètode es feia d’aquesta manera:
objeto = (MiClase.alloc).init;objeto.primeraEtiq ( param1, param2 );
I va passar a escriure d’aquesta altra manera:
objeto = init];;
de manera similar, les declaracions van passar de ser així:
-(void) primeraEtiq ( int param1, int param2 );
a ser així:
-(void) primeraEtiq: (int)param1 segundaEtiq: (int)param2;
Aquesta sintaxi “moderna” no està suportada en dialectes actuals de Objective-C.
Portable Object CompilerEditar
a més de les implementacions de GCC / NeXT / Apple, que van afegir diverses extensions a la implementació original de StepStone, també hi ha una altra implementació lliure i oberta de Objective-C anomenada protable Object Compiler. El conjunt d’extensions implementades pel Portable Object Compiler difereix de les implementacions GCC / NeXT / Apple; en particular, inclou blocks similars als de Smalltalk per Objective-C, mentre que no té protocols i categories, dues característiques usades àmpliament en OpenStep i els seus derivats. En conjunt, POC representa una etapa vella, pre-NeXT, de l’evolució de l’llenguatge, simplement d’acord amb el llibre de 1991 de Brad Cox.
També inclou una llibreria de temps d’execució crida ObjectPak, que està basada a la llibreria original ICPak101 de Cox (que al seu torn deriva de la llibreria de classes Smalltalk-80) i és radicalment diferent de la de OneStep FoundationKit.
GEOS Objective – CEditar
El sistema PC GEOS usava un llenguatge de programació conegut com GEOS Objective – C o GOC ; malgrat el seu similar nom , els dos llenguatges són similars en un concepte global i per l’ús de paraules clau precedides pel signe @ .
ClangEditar
La suite de compiladors Clang , part de el projecte LLVM , implementa Objective – C així com altres llenguatges.