Objective-C: differenze tra le versioni

Versione delle 12:56, 7 feb 2008

Versione attuale delle 15:58, 25 mar 2025

(205 versioni intermedie di oltre 100 utenti non mostrate)

Riga 1:

{{Linguaggio di programmazione

L''''Objective C''', spesso citato anche come '''ObjC''' o '''Objective-C''' o '''Obj-C''', è un [[linguaggio di programmazione]] [[riflessione (informatica)|riflessivo]] [[Programmazione orientata agli oggetti|orientato agli oggetti]], sviluppato da [[Brad Cox]] alla metà degli [[Anni 1980|anni '80]] presso la [[Stepstone]] Corporation.

|nome = Objective-C

|autore = [[Brad Cox]] e [[Tom Love]] ([[Stepstone|Stepstone Corp.]])

|data =

|versione =

|utilizzo = linguaggio general-purpose

|paradigmi =

|tipizzazione = [[Tipo di dato|debole]], [[Tipo di dato#Tipizzazione statica e dinamica|dinamica]]

|specifiche =

|estensione =

|influenzato_da =

|ha_influenzato = [[C++]], [[Swift (linguaggio di programmazione)|Swift]], [[Java (linguaggio di programmazione)|Java]]

|implementazione_riferimento =

|sistema_operativo = [[Multipiattaforma]]

|lingua =

|licenza =

|sito_web =

}}

'''Objective-C''' (in breve '''Obj-C''') è un [[linguaggio di programmazione]] [[riflessione (informatica)|riflessivo]] [[Programmazione orientata agli oggetti|orientato agli oggetti]], sviluppato da [[Brad Cox]] alla metà degli [[Anni 1980|anni ottanta]] presso la [[Stepstone]] Corporation.

Come lo stesso nome suggerisce, l'Objective C è un'estensione a oggetti del [[linguaggio C]]. Esso mantiene la ''completa'' compatibilità col C (a differenza di quanto avviene, per esempio, nel caso del [[C++]]). Tra l'altro, anche a causa di questa compatibilità, Objective C non è dotato di [[forte tipizzazione]] (caratteristica che invece esibiscono, tra gli altri, sia C++ che [[Java_(linguaggio)|Java]]).

Come lo stesso nome suggerisce, l'Objective-C è un'estensione a oggetti del [[linguaggio C]]. Esso mantiene la ''completa'' compatibilità col C (a differenza di quanto avviene, per esempio, nel caso del [[C++]]). Tra l'altro, anche a causa di questa compatibilità, Objective-C non è dotato di [[forte tipizzazione]] (caratteristica che invece esibiscono, tra gli altri, sia C++ che [[Java (linguaggio di programmazione)|Java]]).

Le estensioni a oggetti con cui Objective C arricchisce il modello semantico del C sono ispirate al linguaggio [[Smalltalk]], in particolar modo alla [[comunicazione a scambio di messaggi|gestione dei messaggi]]. Le caratteristiche del ''[[runtime system]]'' collocano l'Objective C tra i linguaggi ad oggetti dinamici. Sono supportati tutti gli elementi classici della programmazione a oggetti; ma non mancano concetti innovativi anche su questo fronte, come il meccanismo delle [[categoria (Objective C)|categorie]] e strumenti legati alla [[riflessione (informatica)|riflessione]].

Le estensioni a oggetti con cui Objective-C arricchisce il modello semantico del C sono ispirate al linguaggio [[Smalltalk]], in particolar modo alla [[comunicazione a scambio di messaggi|gestione dei messaggi]]. Le caratteristiche del ''[[runtime system]]'' collocano l'Objective-C tra i linguaggi ad oggetti dinamici. Sono supportati tutti gli elementi classici della programmazione a oggetti; ma non mancano concetti innovativi anche su questo fronte, come il meccanismo delle [[#Categorie|categorie]] e strumenti legati alla [[riflessione (informatica)|riflessione]].

La sua diffusione è principalmente legata al [[framework]] [[OpenStep]] di [[NeXT]] e al suo successore [[Cocoa]], presente nel sistema operativo [[Mac OS X]] di [[Apple]]. A [[NeXT]] si deve il supporto dell'Objective C nel compilatore [[gcc]] di [[GNU]].

La sua diffusione è principalmente legata al [[framework]] [[OpenStep]] di [[NeXT]] e al suo successore [[Cocoa (software)|Cocoa]], presente nel sistema operativo [[macOS]] di [[Apple]]. A [[NeXT]] si deve il supporto dell'Objective-C nel compilatore [[gNU Compiler Collection|gcc]] di [[GNU]].

==Storia==

===Le origini===

== Storia ==

Nei primi anni '80, la pratica comune dell'[[ingegneria del software]] era basata sulla [[programmazione strutturata]]. Questa modalità era stata sviluppata per poter suddividere programmi di grandi dimensioni in parti più piccole, principalmente per facilitare il lavoro di sviluppo e di manutenzione del software. Ciononostante, col crescere della dimensione dei problemi da risolvere, la programmazione strutturata divenne sempre meno utile, dato che conduceva alla stesura di un numero sempre maggiore di procedure, ad uno ''[[spaghetti code]]'' e ad uno scarso riuso del [[codice sorgente]].

=== Le origini ===

Nei primi [[anni 1980|anni ottanta]], la pratica comune dell'[[ingegneria del software]] era basata sulla [[programmazione strutturata]]. Questa modalità era stata sviluppata per poter suddividere programmi di grandi dimensioni in parti più piccole, principalmente per facilitare il lavoro di sviluppo e di manutenzione del software. Ciononostante, col crescere della dimensione dei problemi da risolvere, la programmazione strutturata divenne sempre meno utile, dato che conduceva alla stesura di un numero sempre maggiore di procedure, ad uno ''[[spaghetti code]]'' e ad uno scarso riuso del [[codice sorgente]].

Venne ipotizzato poi che la [[programmazione orientata agli oggetti]] potesse essere una potenziale soluzione al problema. In effetti [[Smalltalk]] aveva già affrontato molte di queste questioni ingegneristiche, pur con lo svantaggio di necessitare di una [[macchina virtuale]] che interpretava un [[oggetto (informatica)|oggetto]] in memoria chiamato immagine contenente tutti gli strumenti necessari. L'immagine Smalltalk era molto grossa, usava tendenzialmente un'enorme quantità di memoria per l'epoca e girava molto lentamente anche per la mancanza di un supporto specifico dell'[[hardware]] alle macchine virtuali.

L'Objective C fu creato principalmente da [[Brad Cox]] e [[Tom Love]] all'inizio degli [[anni '801980|anni ottanta]] alaalla [[Stepstone]]. Entrambi erano stati introdotti a Smalltalk durante la loro permanenza al Programming Technology Center della [[ITT Corporation]] nel [[1981]]. Cox aveva iniziato ad interessarsi ai problemi legati alla riusabilità del software e si accorse che un linguaggio simile a Smalltalk sarebbe stato estremamente valido per costruire potenti [[framework|ambiente di sviluppo]] per i progettisti di ITT. Cox iniziò così a modificare il compilatore C per aggiungere alcune delle caratteristiche di Smalltalk. Ottenne così ben presto una implementazione funzionante di una estensione ad oggetti del linguaggio C che chiamò ''OOPC'' (Object-Oriented Programming in C). Nel frattempo Love fu assunto da Schlumberger Research nel [[1982]] ed ebbe l'opportunità di acquisire la prima copia commerciale di Smalltalk-80 che influenzò in seguito lo sviluppo della loro creatura.

Per dimostrare che il linguaggio costituiva un reale progresso, Cox mostrò che per realizzare componenti software intercambiabili erano necessari pochi adattamenti pratici agli strumenti già esistenti. Nello specifico, era necessario supportare gli oggetti in modo flessibile con un insieme di [[libreria software|librerie software]] che fossero usabili e consentissero al codice sorgente (e ad ogni risorsa necessaria al codice) di essere ''raccolto'' in un solo formato [[multipiattaforma]].

Riga 19 ⟶ 38:

Cox e Love formarono infine una nuova [[impresa]], la Productivity Products International (PPI), per commercializzare il loro prodotto che accoppiava un compilatore Objective C con una potente classe di librerie.

Nel [[1986]] Cox pubblicò la sua descrizione dell'Objective C nella sua forma originale nel libro ''Object-Oriented Programming, An Evolutionary Approach''. Sebbene fosse attento a puntualizzare che la questione della riusabilità del software non poteva essere esaurita dal [[linguaggio di programmazione]], l'Objective C si trovò spesso ad essere confrontato, caratteristica per caratteristica, con gli altri linguaggi.

=== NeXT ===

Nel [[19981988]], [[NeXT]], la compagnia fondata da [[Steve Jobs]] dopo [[Apple]], ottenne la licenza dell'Objective C da Stepstone (allora proprietaria del [[marchio]]) e realizzò il proprio compilatore Objective C e le librerie sulle quali basò l'[[interfaccia utente]] di [[NeXTSTEP]]. Sebbene le [[workstation]] NeXTSTEP non riuscirono ad avere un forte impatto sul mercato, i loro strumenti vennero ampliamenteampiamente apprezzati dall'industria del settore. Ciò portò NeXTstepNeXT ad abbandonare la produzione di hardware ed a focalizzarsi sugli strumenti software, vendendo NeXTSTEP (e [[OpenStep]]) come piattaforma per la programmazione.

In seguito il [[GNU|progetto GNU]] iniziò a lavorare sul clone gratuitolibero che chiamò [[GNUstep]], basato sullo [[standard (informatica)|standard]] OpenStep. [[Dennis Glatting]] scrisse il primo [[run-time]] gnu-objc nel [[1992]] e [[Richard Stallman]] lo seguì subito dopo con un secondo. ilIl run-time GNU Objective C, che è usato dal [[1993]], è stato sviluppato da [[Kresten Krab Thorup]] mentre era studente universitario in [[Danimarca]].

=== Apple ===

Dopo aver acquisito NeXT nel [[1996]], Apple ha usato OpenStep come base per il suo nuovo [[sistema operativo]] [[Mac OS XmacOS]]. Questo glile consentì di includere l'Objective C di NeXT ed il suo sistema di sviluppo [[Xcode|Project Builder]] (in seguito rinominato [[Xcode]]). La maggior parte delle attuali [[Application programming interface|API]] di Apple ([[Cocoa (software)|API Cocoa]]) sono basate sugli oggetti d'interfaccia di OpenStep e costituiscono il più significativo ambiente di sviluppo basato su Objective C attualmente usato.

== Sviluppi ==

=== Oggi ===

Oggi Objective C è spesso usato in tandem con librerie fisse di oggetti standard (spesso denominati "kit" o "[[framework]]") come [[Cocoa (software)|Cocoa]] o [[GNUstep]]. Queste librerie sono spesso fornite assieme al [[sistema operativo]]: le librerie GNUstep sono parte della collezione di software GNU e a volte presenti in alcune distribuzioni Gnu/Linux e Cocoa di [[MacOS]]. Il programmatore non è obbligato ad ereditare le funzionalità della classe base esistente (NSObject). Objective C permette la dichiarazione di nuove classi base che non ereditino nessuna delle funzionalità preesistenti. Originariamente gli ambienti di programmazione basati su Objective C offrivano la classe Object con alcune funzionalità di base, ma con l'introduzione di [[OpenStep]], [[NeXT]] ha creato una nuova classe base chiamata NSObject che offriva caratteristiche aggiuntive oltre a quelle di Object. Quasi tutte le classi di Cocoa ereditano da NSObject.

La rinominazione non è servita solo per differenziare i nuovi comportamenti delle classi nel nuovo framework, ma ha consentito al codice che ancora usava la classe Object di coesistere (sebbene con alcune limitazioni) nello stesso [[run-time system]]. Nello stesso tempo l'introduzione del prefisso di due lettere è diventato una sorta di surrogato alla mancanza in Objective C degli spacename (o Namespaces che dir si voglia). Usare un prefisso per creare un identificatore di package informale è diventata un'abitudine standard nella comunità di programmatori Objective C.

=== Objective C 2.0 ===

Alla [[Worldwide Developers Conference]] del [[2006]], [[Apple]] ha annunciato l'uscita di "Objective C 2.0" i cui contenuti sono la [[garbage collection]], migliorie nella sintassi<ref>{{cita web | url=https://lists.apple.com/archives/Objc-language/2006/Aug/msg00039.html | titolo=documento Apple | lingua=en | urlmorto=sì | urlarchivio=https://web.archive.org/web/20090618184513/http://lists.apple.com/archives/Objc-language/2006/Aug/msg00039.html | dataarchivio=18 giugno 2009 }}</ref>, miglioramenti delle prestazioni del run-time<ref>{{cita web | url=https://lists.apple.com/archives/Objc-language/2006/Aug/msg00018.html | titolo=documento Apple | lingua=en | urlmorto=sì | urlarchivio=https://web.archive.org/web/20101124014332/http://lists.apple.com/archives/Objc-language/2006/Aug/msg00018.html | dataarchivio=24 novembre 2010 }}</ref> e il supporto ai [[64-bit]]<ref>{{cita web | url=https://developer.apple.com/leopard/overview/tools.html | titolo=documento Apple | lingua=en}}</ref>. Non è ancora noto quando queste evoluzioni saranno supportate nel run-time GNU, sebbene lo siano già in [[Mac OS X Leopard]]<ref>{{cita web | url=https://www.apple.com/macosx/features/300.html#xcode3 | titolo=documento Apple | lingua=en | accesso=3 maggio 2019 | urlarchivio=https://web.archive.org/web/20081215210759/http://www.apple.com/macosx/features/300.html#xcode3 | dataarchivio=15 dicembre 2008 | urlmorto=sì }}</ref>.

==== Garbage collection ====

Objective C 2.0 consente la [[garbage collection]], ma in maniera dipendente dal sistema operativo. Tuttavia è possibile usarla in modo retro-compatibile, in modo che il [[codice sorgente]] scritto per versioni precedenti continui a funzionare.

==== Proprietà ====

Mentre precedentemente le variabili d'istanza richiedevano metodi espliciti di lettura e scrittura (detti ''getters'' e ''setters''), Objective C 2.0 introduce le proprietà (''property'') con la seguente sintassi:

<syntaxhighlight lang="objc">

@interface Persona: NSObject {

}

@property(readonly) NSString *nome;

@property(readonly) int eta;

-(id)initWithName:(NSString)nome eta:(int)eta;

@end

</syntaxhighlight>

Una volta inserite nell'interfaccia, si può accedere alle proprietà usando la notazione descritta nell'esempio:

<syntaxhighlight lang="objc">NSString *nome = unaPersona.nome;</syntaxhighlight>

Il compilatore traduce questa notazione in chiamate di metodi accessori. L'istruzione precedente è equivalente a:

<syntaxhighlight lang="objc">NSString *nome = [unaPersona nome];</syntaxhighlight>

==== Enumerazione veloce ====

== Interfaccia ed implementazione ==

Invece di usare un oggetto enumeratore per operare iterazioni all'interno di una raccolta di oggetti, Objective C 2.0 offre una sintassi di ciclo dedicata; riprendendo l'esempio precedente:

<syntaxhighlight lang="objc">

for (Persona *persona in laGente)

NSLog(@"%@ ha %i anni.", persona.nome, persona.eta);

</syntaxhighlight>

==== Portable Object Compiler ====

L'objective c funziona grazie ad un'interfaccia (scritta in un file ".h") ed una implementazione (scritta in un file ".m"). In alcuni casi queste due parti vengono scritte nello stesso script separate dai tag @interface e @implementation.

Oltre alle implementazioni [[GNU Compiler Collection|GCC]]/[[NeXT]]/[[Apple]], che hanno aggiunto diverse estensioni a quella originale di [[Stepstone]], esiste un'altra implementazione [[Open Source]] di Objective C che aggiunge un set di estensioni lievemente differente: il ''Portable Object Compiler''<ref>{{cita web | url=http://users.pandora.be/stes/compiler.html | titolo=Portable Object Compiler | lingua=en | urlarchivio=https://web.archive.org/web/20080802040731/http://users.pandora.be/stes/compiler.html | dataarchivio=2 agosto 2008 | urlmorto=sì }}</ref> implementa tra l'altro anche dei blocchi di codice sullo stile Smalltalk.

== Sintassi ==

L'Objective C è un sottile strato posto ''sopra'' il [[linguaggio C]]; C quindi è un [[sottoinsieme]] stretto dell'Objective C. Ne consegue che è possibile compilare un qualsiasi programma scritto in C con un compilatore Objective C. La gran parte della [[sintassi]] (clausole del [[preprocessore]], [[espressione (informatica)|espressioni]], [[funzione (informatica)|dichiarazioni e chiamate di funzioni]]) è derivata da quella del C, mentre la sintassi relativa alle caratteristiche [[object-oriented]] è stata creata per ottenere la [[comunicazione a scambio di messaggi]] simile a quella di [[Smalltalk]].

{{T sezione|lingua=inglese|argomento=informatica|data=febbraio 2008}}

l'Objective C è un sottile strato posto ''sopra'' il [[linguaggio C]]; C quindi è uno [[sottoinsieme]] stretto dell'Objective C. Ne consegue che è possibile compilare un qualsiasi programma scritto in C con un compilatore Objective C. La gran parte della [[sintassi]] (clausole del [[preprocessore]], [[espressione (informatica)|espressioni]], [[funzione (informatica)|dichiarazioni e chiamate di funzioni]]) è derivata da quella del C, mentre la sintassi relativa alle caratteristiche [[object-oriented]] è stata creata per ottenere la [[comunicazione a scambio di messaggi]] simile a quella di [[Smalltalk]].

=== Messaggi ===

laLa sintassi aggiunta rispetto al C è intesa al supporto della programmazione ad oggetti. Il modello di programmazione dell'Objective C è basato sullo scambio di messaggi tra oggetti così come avviene in [[Smalltalk]]. Tale modello è differente da quello di [[Simula]], che viene usato in numerosi linguaggi quali, tra gli altri, il [[C++]]. Questa distinzione è [[semantica (informatica)|semanticamente]] importante e consiste principalmente nel fatto che in Objective C non si ''chiama un [[metodo (programmazione)|metodo]]'', ma si ''invia un [[messaggio]]''.

Si dice che un oggetto chiamato ''ogg'' la cui [[classe (informatica)|classe]] implementa il metodo ''faiQualcosa'', ''risponde'' al messaggio ''faiQualcosa''. L'invio del messaggio ''faiQualcosa'' all'oggetto ''ogg'' è espresso da:

<sourcesyntaxhighlight lang="objc">[ogg faiQualcosa];</sourcesyntaxhighlight>

mentre l'azione equivalente in C++ e Java sarebbe espressa da:

<sourcesyntaxhighlight lang="cpp">ogg.faiQualcosa();</sourcesyntaxhighlight>

In questo modo è possibile inviare messaggi ad un oggetto anche se l'oggetto ''non è capace'' di rispondere. Questo differisce dai linguaggi [[tipo di dato|tipizzati]] staticamente come C++ e [[Java (linguaggio di programmazione)|Java]] nei quali tutte le chiamate devodevono essere di metodi predefiniti.

=== Interfacce e implementazioni ===

lL'Objective C richiede che l'[[interfaccia (informatica)|interfaccia]] e l'[[implementazione]] di una classe siano dichiarati in blocchi di codice differenti. Per convenzione l'interfaccia è messa in un file con suffisso ".h", mentre l'implementazione in un file con suffisso ".m".

==== Interfaccia ====

L'interfaccia di una classe è solitamente definita in un file ".h". La convenzione usata è quella di assegnare il nome al file basandosi sul nome della classe, nell'esempio "NomeDellaClasse.h".

<sourcesyntaxhighlight lang="objc">

//definizione dell'interfaccia: "NomeDellaClasse.h"

#import "NomeDellaSuperclasse.h"

@interface nomeDellaClasseNomeDellaClasse : nomeDellaSuperclasseNomeDellaSuperclasse

{

//variabili d'istanza

Riga 77 ⟶ 128:

@end

</syntaxhighlight>

</source>

Il segno meno (-) denota i metodi d'istanza, mentre il segno più (+) quello di classe (analoghi alle funzioni statiche del C++). Si noti la differenza di significato con le convenzioni dei [[Unified Modeling Language|diagrammi UML]] dove i due segni rappresentano rispettivamente i metodi privati e pubblici.

==== Implementazione ====

L'interfaccia dichiara solamente i [[prototipo|prototipi]] dei metodi e non i metodi stessi che vengono inseriti nell'implementazione. L'implementazione è solitamente scritta in un file con estensione ".m".

La convenzione usata è quella di assegnare il nome al file basandosi sul nome della classe, nell'esempio "NomeDellaClasse.m"

<sourcesyntaxhighlight lang="objc">

//definizione dell'implementazione: "NomeDellaClasse.m"

#import "NomeDellaClasse.h"

@implementation nomeDellaClasseNomeDellaClasse

+ metodoDiClasse1

{

Riga 96 ⟶ 147:

...

}

+ metodoDiClasse2

{

// implementazione

Riga 115 ⟶ 166:

@end

</syntaxhighlight>

</source>

I metodi sono scritti in maniera diversa dalle [[funzione (informatica)|funzioni]] in stile C. Ad esempio, una funzione, sia in C che in Objective C segue la seguente forma generale:

<sourcesyntaxhighlight lang="objc">

int fai_la_radice_quadrata(int i)

{

return radice_quadrata(i);

}

</syntaxhighlight>

</source>

che avrà come prototipo:

<sourcesyntaxhighlight lang="objc">int fai_la_radice_quadrata(int);</sourcesyntaxhighlight>

L'implementazione come metodo diverrà:

<sourcesyntaxhighlight lang="objc">

- (int) fai_la_radice_quadrata:(int) i

{

return [self radice_quadrata: i];

}

</syntaxhighlight>

</source>

Un approccio più canonico alla scrittura del metodo sarebbe quello di citare il primo argomento nel nome del selettore:

<sourcesyntaxhighlight lang="objc">

- (int) faiLaRadiceQuadrataDiInt: (int) i

{

return [self radiceQuadrataDiInt:i];

}

</syntaxhighlight>

</source>

Questa sintassi può apparire complicata, ma consente di assegnare i nomi ai [[parametro (informatica)|parametri]], ad esempio:

<sourcesyntaxhighlight lang="objc">

- (int) changeColorWithRed:(int) r green:(int) g blue:(int) b

</syntaxhighlight>

</source>

può essere invocato così:

<sourcesyntaxhighlight lang="objc">

[myColor changeColorWithRed:5 green:2 blue:6];

</syntaxhighlight>

</source>

Le rappresentazioni interne di questi metodi possono variare con le diverse implementazioni di Objective C.

Se ''MyColor''<code>myColor</code>, nell'esempio precedente, fosse della classe ''<code>Color''</code>, internamente il metodo d'istanza ''<code>-changeColorWithRed:green:blue:'' </code> potrebbe essere etichettato ''<code>_i_Color_changeColorWithRed_green_blue''</code>, dove ''<code>i''</code> seguito dal nome della classe, si riferisce al fatto che è un metodo d'istanza ed i due punti (:) sono sostituiti dal [[trattino basso]] (_). Dato che l'ordine dei parametri fa parte del nome del metodo, esso non può essere cambiato.

In ogni caso i nomi interni delle funzioni sono usati raramente in maniera diretta e generalmente anche i messaggi inviati sono convertiti in funzioni definite in librerie di [[run-time]] e non accedono direttamente ai nomi interni. Ciò è dovuto anche al fatto che al momento della [[compilazione]] non sempre si conosce quale metodo sarà effettivamente chiamato, perché la classe del destinatario (l'oggetto a cui viene inviato il messaggio) potrebbe essere sconosciuta fino al run-time.

<!--

=== Protocols ===

=== Protocolli ===

Objective-C was extended at [[NeXT]] to introduce the concept of [[multiple inheritance]] of specification, but not implementation, through the introduction of protocols. This is a pattern achievable either as an abstract multiply inherited base class in C++, or else, more popularly, adopted (e.g., in Java or C#) as an "interface". Objective-C makes use of both ad-hoc protocols, called ''informal protocols'', and compiler enforced protocols called ''formal protocols''.

Objective C è stato esteso da [[NeXT]] per introdurre il concetto di [[ereditarietà multipla]] di specifica, ma non di implementazione, attraverso l'uso dei protocolli. Questo è un [[design pattern|pattern]] ottenibile sia mediante una forma di ereditarietà multipla da una [[classe astratta]] (come in C++), sia (come più comunemente in Java o [[C sharp|C#]]) mediante l'uso di un'[[interfaccia (informatica)#Interfaccia nella programmazione orientata agli oggetti|interfaccia]] (anche in c++ ci sono le interfacce, anche se non esiste una keyword esplicita per dichiararle). Objective C fa uso di entrambi i protocolli, chiamati ''protocolli informali'' e di protocolli imposti dal compilatore detti ''protocolli formali''.

Un protocollo informale è una lista di [[metodo (informatica)|metodi]] che possono essere implementati da una classe. Viene specificato nella documentazione, dato che non è presente esplicitamente nel linguaggio. I protocolli informali spesso includono metodi opzionali, dove l'implementazione del metodo può cambiare il comportamento della classe.

An informal protocol is a list of methods which a class can implement. It is specified in the documentation, since it has no presence in the language. Informal protocols often include optional methods, where implementing the method can change the behavior of a class. For example, a text field class might have a delegate which should implement an informal protocol with an optional autocomplete method. The text field discovers whether the delegate implements that method (via [[Reflection (computer science)|reflection]]), and, if so, calls it to support autocomplete.

Ad esempio una classe con un [[campo (informatica)|campo]] di testo potrebbe avere un "delegato" che dovrebbe implementare un protocollo informale con un metodo opzionale di [[autocompletamento]]. Il campo di testo scopre se il delegato implementa o meno il metodo (attraverso il meccanismo della [[riflessione (informatica)|riflessione]]), e, in caso positivo, lo chiama per supportare l'autocompletamento.

Un protocollo formale è simile ad un'interfaccia Java o C#. Esso consiste di una lista di metodi che ogni classe può dichiarare di implementare. Il compilatore segnalerà un errore se la classe non implementa ogni metodo dei protocolli che dichiara. Il concetto Objective C di protocolli differisce da quello di interfacce di Java e C# nel fatto che una classe può implementare un protocollo senza dichiararlo esplicitamente. La differenza non è individuabile all'esterno del codice. I protocolli formali non possono fornire nessuna implementazione, essi assicurano semplicemente ai chiamanti che le classi che sono conformi al protocollo forniranno le implementazioni. Nelle [[libreria software|librerie]] [[NeXT]]/[[Apple]], i protocolli sono usati di frequente dal sistema ad oggetti distribuiti per rappresentare le capacità di un oggetto eseguito su di un sistema remoto.

A formal protocol is similar to an interface in Java or C#. It is a list of methods which any class can declare itself to implement. The compiler will emit an error if the class does not implement every method of its declared protocols. The Objective-C concept of protocols is different from the Java or C# concept of interfaces in that a class may implement a protocol without being declared to implement that protocol. The difference is not detectable from outside code. Formal protocols cannot provide any implementations, they simply assure callers that classes which conform to the protocol will provide implementations. In the NeXT/Apple library, protocols are frequently used by the Distributed Objects system to represent the capabilities of an object executing on a remote system.

The syntax

La sintassi

<source lang="objc">

<syntaxhighlight lang="objc">

@protocol Locking

- (void)lock;

- (void)unlock;

@end

</syntaxhighlight>

</source>

indica che esiste un'idea astratta di [[lock]]ing che può essere usata; quando è dichiarata in una definizione di classe

<syntaxhighlight lang="objc">

denotes that there is the abstract idea of locking which is useful, and when stated in a class definition

@interface NomeClasse : NomeSuperClasse <Locking>

<source lang="objc">

@interface SomeClass : SomeSuperClass <Locking>

@end

</syntaxhighlight>

</source>

indica che le istanze di ''NomeClasse'' forniranno un'implementazione per i due metodi d'istanza come meglio crederanno. Questa specifica astratta è particolarmente utile per descrivere il comportamento desiderato ad esempio di [[plugin (informatica)|plugin]] senza porre nessuna limitazione su quella che dovrà essere la gerarchia d'implementazione.

denotes that instances of SomeClass will provide an implementation for the two instance methods using whatever means they want. This abstract specification is particularly useful to describe the desired behaviors of plug-ins for example, without constraining at all what the implementation hierarchy should be.

===Dynamic typing===

Objective-C, like Smalltalk, can use [[dynamic typing]]; we can send an object a message not specified in its interface. This can allow for increased flexibility — in Objective-C an object can "capture" this message, and depending on the object, can send the message off again to a different object (who can respond to the message correctly and appropriately, or likewise send the message on again). This behavior is known as ''message forwarding'' or ''delegation'' (see below). Alternatively, an error handler can be used instead, in case the message cannot be forwarded. If the object does not forward the message, handle the error, or respond to it, a [[runtime]] error occurs.

Static typing information may also optionally be added to variables. This information is then checked at compile time. In the following statements, increasingly specific type information is provided. The statements are equivalent at runtime, but the additional information allows the compiler to warn the programmer if the passed argument does not match the type specified. In the first statement, the object must conform to the ''aProtocol'' protocol, and in the second, it must be a member of the NSNumber class.

=== Tipizzazione dinamica ===

<source lang="objc">

Objective C (come Smalltalk) può usare la [[tipo di dato|tipizzazione dinamica]]; ovvero rende possibile, per aumentare la flessibilità, inviare ad un oggetto un messaggio non definito nella propria interfaccia. In Objective C un oggetto può "catturare" questo messaggio e può inviarlo ad un altro oggetto (che può rispondere correttamente o inviare a sua volta il messaggio ad un altro oggetto e così via). Questo comportamento è chiamato ''forwarding'' (in [[lingua italiana|italiano]]: ''inoltro'') o ''delega'' del messaggio (si veda [[#Forwarding|sotto]]). In alternativa, è possibile usare un gestore degli errori nel caso il messaggio non possa essere inoltrato. Nel caso l'oggetto non inoltri il messaggio, non gestisca l'errore o non risponda sarà generato un errore a tempo di esecuzione.

- setMyValue:(id <aProtocol>) foo;

- setMyValue:(NSNumber*)foo;

</source>

Informazioni di tipizzazione statica possono essere aggiunte eventualmente alle variabili. Tali informazioni sono controllate a [[compile-time]]. Nelle istruzioni seguenti, vengono fornite informazioni di tipo sempre più specifiche. Le istruzioni sono equivalenti durante l'esecuzione, ma le informazioni consentono al compilatore di avvisare il programmatore se gli argomenti passati non corrispondono ai tipi specificati. Nella prima istruzione, l'oggetto deve conformarsi al protocollo ''aProtocol'' e, nella seconda, deve essere un membro della classe ''NSNumber''.

Dynamic typing can be a powerful feature. When implementing container classes using statically-typed languages without generics like pre-1.5 Java, the programmer is forced to write a [[Container (data structure)|container class]] for a generic type of object, and then cast back and forth between the abstract generic type and the real type. [[Type conversion|Casting]] however breaks the discipline of [[Type system#Static and dynamic typing|static typing]] – if you put in an [[Integer]] and read out a [[String (computer science)|String]], you get an error. One way of alleviating the problem is to resort to [[generic programming]], but then container classes must be homogeneous in type. This need not be the case with dynamic typing.

<syntaxhighlight lang="objc">

- setMyValue:(id <aProtocol>) foo;

- setMyValue:(NSNumber*)foo;

</syntaxhighlight>

La tipizzazione dinamica può essere una caratteristica molto potente. Se si implementano [[classe container|classi container]] usando linguaggi a tipizzazione statica come Java (prima della versione 1.5), il programmatore è costretto a scrivere classi container per oggetti generici e poi usare la [[conversione di tipo]] per adattarli ad oggetti specifici; tale conversione, comunque, contraddice la disciplina semantica della tipizzazione statica.

=== Forwarding ===

SinceDato che Objective- C permitspermette thel'invio sendingdi ofun amessaggio messagead toun anoggetto objectche whichpotrebbe mightnon notrispondere respondad to itesso, thel'oggetto objectpuò hasgestire atale numbermessaggio ofin thingsaltri itmodi. canUno dodi withquesti thepotrebbe message.consistere Onenel ofsuo these''inoltro'' things(in could[[lingua beinglese|inglese]]: to''forwarding'') forwardad theun messagealtro onoggetto toche ansia objectin whichgrado candi respondrispondere. toIl it.forwarding Forwardingpuò canessere beusato usedper toimplementare implementsemplicemente certainalcuni [[design pattern (computer science)|design patterns]], such as thequali l'[[Observer pattern]] oro theil [[Proxy pattern]] very simply.

Il [[run-time system]] di Objective C specifica una coppia di metodi della classe <code>Object</code>

The Objective-C runtime specifies a pair of methods in <tt>Object</tt>

* metodi di forwarding:

* forwarding methods:

<sourcesyntaxhighlight lang="objc">

- (retval_t) forward:(SEL) sel :(arglist_t) args; // withcon GCC

- (id) forward:(SEL) sel :(marg_list) args; // withcon sistemi NeXT/Apple systems

</syntaxhighlight>

</source>

* actionmetodi methodsdi azione:

<sourcesyntaxhighlight lang="objc">

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

- (id) performv:(SEL) sel :(marg_list) args; // withcon sistemi NeXT/Apple systems

</syntaxhighlight>

</source>

ande asse suchun anoggetto objectvuole wishingimplementare to implementil forwarding needsnecessita onlysolamente todi "[[override|sovrascrivere]]" thei metodi di forwarding methodper todefinire defineil theproprio forwarding behaviourcomportamento. TheI actionmetodi methodsdi azione <ttcode>performv::</ttcode> neednon notnecessitano be overridden as this method merely performs the method based on the selector and argumentsoverride.

==== ExampleEsempio ====

HereEcco isun anesempio exampledi ofprogramma ache programillustra whichi demonstratesfondamenti the basics ofdel forwarding.

; ''Forwarder.h''

<sourcesyntaxhighlight lang="objc">

#import <objc/Object.h>

@interface Forwarder : Object

{

id recipient; //TheL'oggetto objecta wecui wantvogliamo toinoltrare forwardil the message to.messaggio

}

//Metodi accessori

//Accessor methods

- (id) recipient;

- (void) setRecipient:(id) _recipient;

@end

</syntaxhighlight>

</source>

; ''Forwarder.m''

<sourcesyntaxhighlight lang="objc">

#import "Forwarder.h"

Riga 247 ⟶ 292:

{

/*

* Controlla se il destinatario risponde effettivamente al messaggio.

* Check whether the recipient actually responds to the message.

* ThisCiò maypotrebbe oro maymeno notessere be desirabledesiderabile, forad exampleesempio, ifse aun recipientdestinatario

* non risponde al messaggio, potrebbe inoltrare egli stesso il messaggio.

* in turn does not respond to the message, it might do forwarding

* itself.

*/

if([recipient respondsTo:sel])

return [recipient performv: sel : args];

else

return [self error:"RecipientIl doesdestinatario notnon respondrisponde"];

}

Riga 269 ⟶ 313:

}

@end

</syntaxhighlight>

</source>

; ''Recipient.h''

<sourcesyntaxhighlight lang="objc">

#import <objc/Object.h>

// AUn simplesemplice Recipientoggetto objectdestinatario.

@interface Recipient : Object

- (id) hello;

@end

</syntaxhighlight>

</source>

; ''Recipient.m''

<sourcesyntaxhighlight lang="objc">

#import "Recipient.h"

Riga 289 ⟶ 333:

- (id) hello

{

printf("RecipientIl saysdestinatario helloti saluta!\n");

return self;

Riga 295 ⟶ 339:

@end

</syntaxhighlight>

</source>

; main.m

<sourcesyntaxhighlight lang="objc">

#import "Forwarder.h"

#import "Recipient.h"

Riga 308 ⟶ 352:

Recipient *recipient = [Recipient new];

[forwarder setRecipient:recipient]; //SetSetta theil recipient.destinatario

/*

* Si noti che il "forwarder" non risponde al messaggio!

* Observe forwarder does not respond to a hello message! It will

* Esso sarà inoltrato. Tutti i metodi non riconosciuti saranno

* be forwarded. All unrecognized methods will be forwarded to

* inoltrati al destinatario (se il destinatario li gestisce,

* the recipient

* (ifcome the recipient responds to them, as writtendetto in the "Forwarder").

*/

[forwarder hello];

Riga 319 ⟶ 363:

return 0;

}

</syntaxhighlight>

</source>

==== Note ====

Se dovessimo compilare l'esempio, il compilatore segnalerebbe

==== Notes ====

If we were to compile the program, the compiler would report

$ gcc -x objective-c -Wno-import Forwarder.m Recipient.m main.m -lobjc

main.m: In function `main':

Riga 329 ⟶ 373:

$

Il compilatore segnala ciò che è stato spiegato prima, che <code>Forwarder</code> non risponde al messaggio. In certi casi, questa segnalazione può aiutare a trovare degli errori, ma in questo caso può essere ignorata dato che è stato implementato il forwarding. Per eseguire il programma basterà:

The compiler is reporting the point made earlier, that <tt>Forwarder</tt> does not respond to hello messages. In certain circumstances, such a warning can help us find errors, but in this circumstance, we can safely ignore this warning, since we have implemented forwarding. If we were to run the program

$ ./a.out

Recipient says hello!

===Categories Categorie ===

L'esperienza del mondo della [[programmazione strutturata]] aveva dimostrato che uno dei modi per migliorare la struttura del [[codice sorgente]] è quello di suddividerlo in parti più piccole. Per migliorare questo processo Objective C ha introdotto il concetto di ''categoria''.

Le categorie permettono di aggiungere separatamente metodi ad una classe. Il programmatore può mettere dei gruppi di metodi correlati in una categoria per renderli più leggibili. Ad esempio, è possibile creare una categoria ''ControlloOrtografico'' "su" un [[oggetto (informatica)|oggetto]] di tipo [[stringa (informatica)|stringa]] per raccogliere in un unico punto tutti i metodi relativi al controllo ortografico.

Cox’s main concern was the maintainability of large code bases. Experience from the structured programming world had shown that one of the main ways to improve code was to break it down into smaller pieces. Objective-C added the concept of ''Categories'' to help with this process.

Inoltre, i metodi inseriti in una categoria, sono aggiunti alla [[classe (informatica)|classe]] al [[run-time]]. In questo modo le categorie consentono al programmatore di aggiungere metodi ad una classe esistente senza necessità di ricompilazione e senza la necessità di avere il codice sorgente della stessa. Nell'esempio, se il sistema a disposizione non fornisce il supporto del controllo ortografico nell'implementazione della classe Stringa, è possibile aggiungerlo senza modificarne il sorgente.

A category collects method implementations into separate files. The programmer can place groups of related methods into a category to make them more readable. For instance, one could create a "SpellChecking" category "on" the String object, collecting all of the methods related to spell checking into a single place.

I metodi inseriti nelle categorie sono virtualmente parte della classe quando il programma è in esecuzione. Una categoria accede inoltre a tutte le variabili d'istanza della classe, anche quelle private.

Furthermore, the methods within a category are added to a class at [[runtime]]. Thus, categories permit the programmer to add methods to an existing class without the need to recompile that class or even have access to its source code. For example, if the system you are supplied with does not contain a [[spell checker]] in its String implementation, you can add it without modifying the String source code.

Le categorie forniscono una soluzione ai problemi legati alla "fragilità delle classi base" per ciò che concerne i metodi.

Methods within categories become indistinguishable from the methods in a class when the program is run. A category has full access to all of the instance variables within the class, including private variables.

Se si dichiara un metodo in una categoria con la stessa [[firma (programmazione)|firma]] di un metodo già esistente in una classe, viene adottato il metodo della categoria. In questo modo le categorie, non solo possono aggiungere metodi alle classi, ma possono anche sostituire metodi già esistenti. Questa caratteristica può essere usata per correggere errori in altre classi, semplicemente riscrivendone i metodi, o per cambiare il comportamento di una classe in un dato programma. Se due categorie hanno metodi con la stessa firma, non è definito quale metodo andrà effettivamente in esecuzione.

Categories provide an elegant solution to the [[fragile base class]] problem for methods.

Diversi linguaggi hanno tentato di aggiungere questa caratteristica in vari modi. Il [[linguaggio TOM]] ha portato ulteriormente avanti il concetto consentendo anche di aggiungere variabili. Altri linguaggi, come ad esempio il [[Self (linguaggio di programmazione)|Self]], hanno adottato invece soluzioni orientate ai [[prototipo (programmazione)|prototipi]],

If you declare a method in a category with the same [[method signature]] as an existing method in a class, the category’s method is adopted. Thus categories can not only add methods to a class, but also replace existing methods. This feature can be used to fix bugs in other classes by rewriting their methods, or to cause a global change to a class’ behavior within a program. If two categories have methods with the same method signature, it is undefined which category’s method is adopted.

==== Esempio ====

Other languages have attempted to add this feature in a variety of ways. [[TOM (object-oriented programming language)|TOM]] took the Objective-C system a step further and allowed for the addition of variables as well. Other languages have instead used [[Prototype-based programming|prototype oriented]] solutions, the most notable being [[Self programming language|Self]].

Questo esempio costruisce una classe <code>Integer</code>, definendo prima una classe base con solo pochi metodi implementati e aggiungendo in seguito due categorie, <code>Arithmetic</code> e <code>Display</code>, che estendono la classe base. Anche se queste categorie possono accedere alle variabili private della classe base, è buona norma accedere a tali variabili attraverso metodi di servizio che aiutano a tenere le categorie il più indipendenti possibili dalle classi che estendono. Questo è un tipico caso di uso delle categorie per aggiungere o modificare certi metodi della classe base (anche se non è considerata una buona abitudine quella di usare le categorie per sovrascrivere le sottoclassi).

==== Example usage of categories ====

This example builds up an <tt>Integer</tt> class, by defining first a basic class with only [[Method (computer science)|accessor method]]s implemented, and adding two categories, <tt>Arithmetic</tt> and <tt>Display</tt>, which extend the basic class. Whilst categories can access the base class’ private data members, it is often good practice to access these private data members through the accessor methods, which helps keep categories more independent from the base class. This is one typical usage of categories&mdash;the other is to use categories to add or replace certain methods in the base class (however it is not regarded as good practice to use categories for subclass overriding).

; ''Integer.h''

<sourcesyntaxhighlight lang="objc">

#include <objc/Object.h>

@interface Integer : Object

{

int integer;

}

- (int) integer;

- (id) integer: (int) _integer;

@end

</syntaxhighlight>

</source>

; ''Integer.m''

<sourcesyntaxhighlight lang="objc">

#import "Integer.h"

@implementation Integer

- (int) integer

{

return integer;

}

- (id) integer: (int) _integer

{

integer = _integer;

return self;

}

}

@end

@end

</source>

</syntaxhighlight>

; ''Arithmetic.h''

<sourcesyntaxhighlight lang="objc">

#import "Integer.h"

@interface Integer (Arithmetic)

- (id) add: (Integer *) addend;

- (id) sub: (Integer *) subtrahend;

@end

</syntaxhighlight>

</source>

; ''Arithmetic.m''

<sourcesyntaxhighlight lang="objc">

#import "Arithmetic.h"

@implementation Integer (Arithmetic)

- (id) add: (Integer *) addend

{

return [self integer: [self integer] + [addend integer]];

}

- (id) sub: (Integer *) subtrahend

{

return [self integer: [self integer] - [subtrahend integer]];

}

@end

</syntaxhighlight>

</source>

; ''Display.h''

<sourcesyntaxhighlight lang="objc">

#import "Integer.h"

@interface Integer (Display)

- (id) showstars;

- (id) showint;

@end

</syntaxhighlight>

</source>

; ''Display.m''

<sourcesyntaxhighlight lang="objc">

#import "Display.h"

@implementation Integer (Display)

- (id) showstars

{

int i, x = [self integer];

for(i=0; i < x; i++)

printf("*");

printf("\n");

return self;

}

- (id) showint

{

printf("%d\n", [self integer]);

return self;

}

@end

</syntaxhighlight>

</source>

; ''main.m''

<sourcesyntaxhighlight lang="objc">

#import "Integer.h"

#import "Arithmetic.h"

#import "Display.h"

int main(void)

int

{

main(void)

Integer *num1 = [Integer new], *num2 = [Integer new];

{

int x;

Integer *num1 = [Integer new], *num2 = [Integer new];

printf("Enter an integer: ");

int x;

printfscanf("Enter%d", an integer: "&x);

[num1 scanf("%d", &integer:x)];

[num1 integer:xshowstars];

printf("Enter an integer: ");

[num1 showstars];

printfscanf("Enter%d", an integer: "&x);

[num2 scanf("%d", &integer:x)];

[num2 integer:xshowstars];

[num2 showstars];

[num1 add:num2];

[num1 add:num2showint];

}

[num1 showint];

</syntaxhighlight>

}

</source>

==== Note ====

la compilazione si effettua così:

==== Notes ====

Compilation is performed, for example, by

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

Si può provare ad omettere le linee <code>#import "Arithmetic.h"</code> e <code>[num1 add:num2]</code> e ad omettere <code>Arithmetic.m</code> in compilazione. Il programma girerà lo stesso. Ciò significa che è possibile aggiungere o togliere categorie, dato che se non si ha bisogno di una certa funzionalità offerta da una categoria, basta semplicemente escluderla dalla compilazione.

One can experiment by omitting the <tt>#import "Arithmetic.h" </tt> and <tt>[num1 add:num2]</tt>

lines and omit <tt>Arithmetic.m</tt> in compilation. The program will still run. This means that it is possible to "mix-and-match" added categories if necessary – if one does not need to have some capability provided in a category, one can simply not compile it in.

=== Posing ===

Objective C permette ad una classe di sostituirne completamente un'altra; questo meccanismo è detto ''posing'' (dall'[[lingua inglese|inglese]] ''pose as'': fingersi per qualcun altro). La classe sostituita è chiamata ''classe target'' e la classe che sostituisce è chiamata ''classe posing''. Tutti i messaggi inviati alla classe target vengono ricevuti in sua vece dalla classe posing. Esistono numerose restrizioni da rispettare per effettuare il posing:

Objective-C permits a class to wholly replace another class within a program. The replacing class is said to "pose as" the target class. All messages sent to the target class are then instead received by the posing class. There are several restrictions on which classes can pose:

* Una classe può solo sostituirsi a una delle sue [[superclasse (informatica)|superclassi]] dirette o indirette.

* A class may only pose as one of its direct or indirect superclasses

* TheLa classe posing classnon mustdeve notdefinire definenessuna anynuova newvariabile instanced'istanza variablesche whichsia areassente absentdalla from theclasse target class (thoughanche itse maypuò definedefinire oro overridesovrascrivere methodsmetodi).

* NoNessun messagesmessaggio mustdeve haveessere beeninviato sentalla to theclasse target class prior toprima thedel posing.

Il posing, similmente alle categorie, consente un aumento globale delle classi esistenti e permette due possibilità assenti nelle categorie:

Posing, similarly to categories, allows globally augmenting existing classes. Posing permits two features absent from categories:

* AUna classe posing classpuò canchiamare callmetodi overriddensovrascritti methods throughattraverso ''super'', thusincorporando incorporatingcosì thel'implementazione implementationdella of theclasse target class.

* AUna classe posing classpuò cansovrascrivere overridei methodsmetodi defineddefiniti innelle categoriescategorie.

Ad esempio:

For example,

<syntaxhighlight lang="objc">

<source lang="objc">

@interface CustomNSApplication : NSApplication

@end

Riga 495 ⟶ 538:

- (void) setMainMenu: (NSMenu*) menu

{

// dofa somethingqualcosa withcol menu

}

@end

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

</syntaxhighlight>

</source>

ThisQuesto interceptsintercetta everyogni invocationinvocazione ofa setMainMenu todi NSApplication.

However, classIl posing wasè declaredstato deprecateddichiarato withdeprecato MacOScon X[[Mac 10.5OS X (Leopard)]] ande unavailablenon inè thedisponibile 64nei run-bittime runtimea 64 bit.

=== #import ===

In the C language, thela direttiva del [[precompilatore]] ''#include'' pre-compileconsente directivedi allowsinserire forun theintero insertion[[file]] ofprima entiredell'inizio fileseffettivo beforedella any compilation actually begins[[compilazione]]. Objective-C addsaggiunge thea questa la direttiva ''#import'' directive, whichche doesoltre thea samesvolgere thing,lo exceptstesso thatruolo itdella knowsprecedente, notevita todi insertincludere ail file whichqualora sia già hasstato alreadyincluso beenin insertedprecedenza.

ForAd exampleesempio, ifil file A includesinclude filesi file X ande Y, butma X ande Y eachincludono includeciascuno theil file Q, thenin Qquesto willcaso beQ insertedverrebbe twiceincluso intodue thevolte resultantnel file, causingrisultante causando così delle definizioni "duplicate definition"e compilequindi errors.un errore Butin ifcompilazione. Se il file Q isvenisse includedincluso usingcon thela direttiva ''#import'' directive, onlysolo thela firstprima inclusioninclusione ofverrebbe Qeffettivamente effettuata wille occur—alltutte othersle willsuccessive beverrebbero ignoredignorate.

AAlcuni few compilerscompilatori, includingcompreso [[GNU Compiler Collection|GCC]], supportsupportano la clausola ''#import'' foranche Cper programsil toolinguaggio C; itsil usesuo isuso discouragedviene oncomunque thescoraggiato basissulla thatbase thedel ''user''fatto ofche thel'utilizzatore headerdei file hasda toincludere distinguishdovrebbe headersdistinguere whichquali shouldfile beincludere includedsolo onlyuna once,volta fromda headersquelli designedprogettati toper beessere usedinclusi multiplepiù timesvolte. ItQuesto isonere argueddovrebbe thatin thisteoria burdenessere shoulda becarico placeddell'implementatore ondel thefile implementor;da toincludere thische end,può theusare implementorla may place the directivedirettiva ''#[[pragma once]]'' ino theusare headerla file, or use the traditional ''[[includeInclude guard|tradizionale tecnica]]'' technique:

<syntaxhighlight lang="Cpp">

#ifndef H_PERSONA

#define H_PERSONA

// ... contenuto di header.h ...

#endif

</syntaxhighlight>

In questo caso le direttive ''#include'' e ''#import'' diventano equivalenti.

== Altre caratteristiche ==

#ifndef HEADER_H

Objective C ha incluso sin dal suo apparire una lista di caratteristiche che sono tuttora in via di acquisizione in altri linguaggi, oltre ad alcune che sono rimaste sue uniche prerogative. Ciò ha permesso di mettere in luce, partendo dalla realizzazione di Cox (ed in seguito da quella di [[NeXT]]), che alcuni considerazioni superano i concetti più strettamente legati al linguaggio. Il sistema deve essere usabile e flessibile nel complesso per poter essere pienamente fruibile.

#define HEADER_H

... contents of header.h ...

#endif

* Delegare i metodi ad altri oggetti al [[run-time]] è banale. Basta semplicemente aggiungere una categoria comprendente le modifiche ad un metodo per implementare il forwarding al destinatario della delega.

If a header file uses guards or ''#pragma once'', it makes no difference whether it is ''#include''d or ''#import''ed. The same objection to ''#import'' actually applies to Objective-C as well, and many Objective-C programs also use guards in their headers.

* La [[chiamata di procedura remota]] è banale. Basta semplicemente aggiungere una categoria con un metodo che "[[serializzi]]" l'invocazione e la inoltri.

* Lo [[swizzling]] dei [[puntatore (informatica)|puntatori]] consente di modificare le classi al run-time. Tipicamente per scopi di [[debugging]] se un oggetto la cui memoria è stata rilasciata dovesse venire referenziato per errore.

* Un oggetto può essere archiviato su uno [[stream (informatica)|stream]] (ad esempio un [[file]]) e può essere riletto e recuperato su richiesta.

== OtherObjective featuresC++ ==

Objective C++ è un [[front-end]] del compilatore [[GNU Compiler Collection|gcc]] in grado di compilare [[codice sorgente]] che usa una sintassi combinazione di C++ e Objective C. Objective C++ aggiunge a C++ le stesse estensioni che Objective C aggiunge a C. Dato che nulla è stato fatto per unificare le differenze semantiche tra i due linguaggi, sono state applicate alcune restrizioni:

Objective-C has from the beginning included a list of features which are still being added to other languages, and some which are unique to it. These led from Cox’s (and later, [[NeXT]]'s) realization that there is considerably more to programming than the language. The system has to be usable and flexible as a whole in order to work in a real-world setting.

* una classe C++ non può derivare da una classe Objective C e viceversa

* i [[namespace]] C++ non possono essere dichiarati all'interno di una dichiarazione Objective C

* le classi Objective C non possono contenere variabili di istanza di classi C++ che non abbiano un [[Costruttore (informatica)|costruttore]] di [[default (informatica)|default]] o che abbiano uno o più [[metodo virtuale|metodi virtuali]], ma si possono usare [[puntatore (programmazione)|puntatori]] ad oggetti C++ come variabili di istanza senza restrizioni

* la semantica "per valore" del C++ non può essere applicata agli oggetti Objective C, i quali rimangono accessibili solo mediante puntatori

* non ci possono essere dichiarazioni Objective C in dichiarazioni di [[template]] C++ e viceversa. Comunque è possibile usare tipi Objective C (es. Nomeclasse *) come parametri di template C++

* La gestione delle eccezioni Objective C è distinta da quella di C++

== Analisi del linguaggio ==

* Delegating methods to other objects at run-time is trivial. Simply add a category which changes the "second chance" method to forward the invocation to the delegate.

L'implementazione dell'Objective C usa un semplice [[run-time system]] scritto in [[linguaggio C]] che aumenta di poco la dimensione delle applicazioni. Al contrario, la maggior parte dei sistemi object-oriented esistenti quando fu creato (e [[Java (linguaggio di programmazione)|Java]] tuttora) usava una grossa [[macchina virtuale]] invasiva per l'intero sistema. I programmi scritti in Objective C tendono ad essere di poco più grandi delle dimensioni del loro [[codice oggetto]] e delle [[libreria software|librerie]] usate (che generalmente non devono essere incluse nel codice distribuito), al contrario ad esempio dei sistemi [[Smalltalk]] dove grandi quantità di memoria sono necessarie semplicemente per aprire una [[finestra (informatica)|finestra]].

* [[Remote procedure call|Remote invocation]] is trivial. Simply add a category which changes the "second chance" method to serialize the invocation and forward it off.

* [[Swizzling]] of the <var>isa</var> pointer allows for classes to change at runtime. Typically used for [[debugging]] where freed objects are swizzled into zombie objects, whose only purpose is to report an error when someone calls them. Swizzling was also used in [[Enterprise Objects Framework|EOF]] to create database faults. Swizzling is used today by Apple’s Foundation Framework to implement [[Key-Value Observing]].

* Archiving. An object can be archived into a stream, such as a file, and can be read and restored on demand.

Il linguaggio può essere implementato con un compilatore C (in [[GNU Compiler Collection|GCC]], prima come un [[preprocessore]] ed in seguito come un modulo del compilatore) piuttosto che con un nuovo compilatore. Ciò consente all'Objective C di sfruttare l'enorme mole di codice, librerie e strumenti già esistenti in C che può essere adattata in Objective C per fornire un'interfaccia object-oriented. Tutti questi fattori riducono le barriere d'ingresso al nuovo linguaggio, fattore che costituì il problema principale di Smalltalk negli [[anni 1980|anni ottanta]].

== Objective-C++ ==

Objective-C++ is a front-end to the [[GNU Compiler Collection]] which can compile source files which use a combination of C++ and Objective-C syntax. Objective-C++ adds to C++ the extensions Objective-C adds to C. As nothing is done to unify the semantics behind the various language features, certain restrictions apply:

* A C++ class cannot derive from an Objective-C class and vice versa.

* C++ namespaces cannot be declared inside an Objective-C declaration.

* Objective-C classes cannot have instance variables of C++ classes which do not have a default constructor or which have one or more virtual methods, but pointers to C++ objects can be used as instance variables without restriction (allocate them with new in the -init method).

* C++ "by value" semantics cannot be applied to Objective-C objects, which are only accessible through pointers.

* An Objective-C declaration cannot be within a C++ template declaration and vice versa. Objective-C types, (e.g., Classname *) can be used as C++ template parameters, however.

* Objective-C and C++ exception handling is distinct; the handlers of each cannot handle exceptions of the other type.

* Care must be taken since the destructor calling conventions of Objective-C and C++’s exception run-time models do not match (i.e., a C++ destructor will not be called when an Objective-C exception exits the C++ object’s scope).

Le prime versioni di Objective C non supportavano la [[garbage collection]]. Al tempo questa scelta fu oggetto di discussioni e in molti (ai tempi di Smalltalk) la consideravano un lungo "tempo morto" in cui il sistema era reso non più utilizzabile. Anche se qualche implementazione di terze parti (principalmente [[GNUstep]]) aveva già aggiunto questa caratteristica, è stata implementata da [[Apple]] una tecnica simile tramite [[Automatic Reference Counting|ARC]] in [[Mac OS X Leopard]], ma non è disponibile per applicazioni implementate per versioni precedenti del [[sistema operativo]].<ref>{{Cita web | url=https://www.apple.com/macosx/developertools/xcode.html | titolo=Mac OS X Leopard – Xcode 3.0 | autore=Apple, Inc. | anno=22 agosto 2006 | sito=apple.com | accesso=22 agosto 2006 | lingua=en | urlarchivio=https://web.archive.org/web/20071024144921/http://www.apple.com/macosx/developertools/xcode.html | dataarchivio=24 ottobre 2007 | urlmorto=sì }}</ref>

==Today==

Un'altra critica comunemente fatta all'Objective C è quella di non avere un supporto nativo per i [[namespace]]. I programmatori sono perciò costretti ad aggiungere prefissi in maniera più o meno arbitraria ai nomi delle classi che implementano, fatto che può causare collisioni. Dal [[2007]] tutte le classi e le funzioni di [[macOS]] in ambiente [[Cocoa (software)|Cocoa]] hanno il prefisso "NS" (es. ''NSObject'' o ''NSButton'') per identificarle chiaramente; "NS" deriva dal nome delle classi definite durante lo sviluppo di [[NeXTSTEP]].

Objective-C today is often used in tandem with a fixed library of standard objects (often known as a "kit" or "framework"), such as Cocoa or GNUstep. These libraries often come with the operating system: the GNUstep libraries often come with [[Linux distribution]]s and Cocoa comes with Mac OS X. The programmer is not forced to inherit functionality from the existing base class (NSObject). Objective-C allows for the declaration of new root classes which do not inherit any existing functionality. Originally, Objective-C based programming environments typically offered an Object class as the base class from which almost all other classes inherited. With the introduction of OpenStep, NeXT created a new base class named NSObject which offered additional features over Object (an emphasis on using object references and reference counting instead of raw pointers, for example). Almost all classes in Cocoa inherit from NSObject.

Dato che Objective C è uno stretto [[superinsieme]] del C, non tratta i tipi primitivi del C come [[first-class object]].

Not only did the renaming serve to differentiate the new default behavior of classes within the OpenStep API, but it allowed code which used Object — the original base class used on NeXTSTEP (and, more or less, other Objective-C class libraries) — to co-exist in the same runtime with code which used NSObject (with some limitations). As well, the introduction of the two letter prefix became a sort of simplistic form of namespaces, which Objective-C lacks. Using a prefix to create an informal packaging identifier became an informal coding standard in the Objective-C community, and continues to this day.

A differenza del C++, Objective C non supporta l'[[overloading]] degli operatori, consente l'[[ereditarietà (informatica)|ereditarietà]] solo diretta da una singola classe (vietando così l'[[ereditarietà multipla]]). Dato che il [[linguaggio Java]] venne influenzato dall'Objective C, la decisione di usare l'ereditarietà singola venne portata anche in Java. In alternativa all'ereditarietà multipla possono essere usate le [[#Categorie|categorie]] ed i [[#Protocolli|protocolli]].

===Objective-C 2.0===

At the 2006 [[Worldwide Developers Conference]], Apple Computer announced the forthcoming release of "Objective-C 2.0". Apple has announced that "modern garbage collection, syntax enhancements[http://lists.apple.com/archives/Objc-language/2006/Aug/msg00039.html], runtime performance improvements[http://lists.apple.com/archives/Objc-language/2006/Aug/msg00018.html], and 64-bit support" will be available[http://developer.apple.com/leopard/overview/tools.html]. It is not yet known when these language improvements will be available in the GNU runtime, although Apple already supports it in Mac OS X Leopard.[http://www.apple.com/macosx/features/300.html#xcode3].

=== Differenze filosofiche tra Objective C e C++ ===

====Garbage collection====

Il progetto e l'implementazione del [[C++]] e dell'Objective C rappresentano due diversi approcci all'estensione del C.

Objective-C 2.0 allows for garbage collection, but it is an opt-in system. One may use garbage collection in a backwards compatible way, such that code written for previous versions will continue to work.

Oltre alla [[programmazione strutturata]] del C, C++ supporta direttamente la [[programmazione ad oggetti]], la programmazione generica e la [[metaprogrammazione]]. C++ è inoltre corredato di una estesa libreria standard che include numerose [[oggetto container (informatica)|classi container]]. L'Objective C, invece, aggiunge solo delle caratteristiche [[object-oriented]] al C; esso, nella sua versione più "pura" non offre lo stesso in termini di librerie standard, ma in molti contesti dove viene usato, viene corredato di una libreria sul modello di quella di [[OpenStep]], di [[Cocoa (software)|Cocoa]] o di [[GNUstep]] le quali forniscono funzionalità simili a quelle offerte dalla libreria standard di C++.

====Properties====

Whereas instance variables previously required the creation of methods to get and set (getters and setters) those variables, Objective-C 2.0 introduces the property syntax:

Un'altra notevole differenza consiste nel fatto che l'Objective C fornisce un maggior supporto run-time alla [[riflessione (informatica)|riflessione]] rispetto a C++. In Objective C si può interrogare un oggetto riguardo alle sue stesse proprietà, ad esempio se possa o meno rispondere ad un dato messaggio, mentre in C++ ciò è impossibile a meno di fare ricorso a librerie esterne. Comunque è possibile chiedere se due oggetti sono o meno dello stesso tipo (inclusi i tipi predefiniti) e se un oggetto è istanza di una data [[classe (informatica)|classe]] (o [[superclasse (informatica)|superclasse]]).

<source lang="objc">

@interface Person : NSObject {

}

@property(readonly) NSString *name;

@property(readonly) int age;

-(id)initWithName:(NSString)name age:(int)age;

@end

</source>

L'uso della riflessione fa parte di una più ampia distinzione tra caratteristiche dinamiche ([[run-time]]) e statiche ([[compile-time]]) dei linguaggi. Sebbene sia Objective C che C++ implementino un misto di entrambe le caratteristiche, Objective C è decisamente più orientato verso le decisioni dinamiche, mentre C++ verso quelle effettuate al momento della compilazione.

Once added to the interface, properties can be accessed using dot notation (example given an instance aPerson of the above Person class):

NSString *name = aPerson.name;

The compiler translates property dot notation into accessor method calls. The above statement is equivalent to:

NSString *name = [aPerson name];

====Fast Enumeration==Note ==

<references />

Instead of using an Enumerator object to iterate through a collection, Objective-C 2.0 offers the foreach syntax (given an array thePeople of objects of the above defined Person):

== Bibliografia ==

<source lang="objc">

* {{cita libro|autore=Brad J. Cox|titolo=Object Oriented Programming: An Evolutionary Approach|url=https://archive.org/details/objectorientedpr0000coxb|edizione=2|anno=1991|editore=Addison-Wesley|lingua=inglese|ISBN=0201548348}}

for (Person *person in thePeople)

NSLog(@"%@ is %i years old.", person.name, person.age);

</source>

=== PortableAltri Objectprogetti Compiler ===

{{interprogetto|preposizione=sull'}}

Besides the [[GNU Compiler Collection|GCC]]/[[NeXT]]/[[Apple Computer]] implementation, which added several extensions to the original [[Stepstone]] implementation, there exists another free open-source Objective-C implementation, which implements a slightly different set of extensions: The Portable Object Compiler [http://users.pandora.be/stes/compiler.html] implements, among other things, also [[Smalltalk]]-like blocks for Objective-C.

== AnalysisCollegamenti of the languageesterni ==

* {{Collegamenti esterni}}

Objective-C implementations use a thin [[runtime]] written in C which adds little to the size of the application. In contrast, most OO systems at the time that it was created (and Java even today) used large [[virtual machine|VM]] runtimes which took over the entire system. Programs written in Objective-C tend to be not much larger than the size of their code and that of the libraries (which generally do not need to be included in the [[software distribution]]), in contrast to Smalltalk systems where a large amount of memory was used just to open a window.

* {{FOLDOC}}

* {{cita web | 1 = http://programmazione.html.it/guide/leggi/183/guida-objective-c/ | 2 = Guida Objective C - HTML.it | accesso = 5 febbraio 2010 | dataarchivio = 23 luglio 2010 | urlarchivio = https://web.archive.org/web/20100723144028/http://programmazione.html.it/guide/leggi/183/guida-objective-c | urlmorto = sì }}

Likewise, the language can be implemented on top of existing C compilers (in [[GNU Compiler Collection|GCC]], first as a preprocessor, then as a module) rather than as a new compiler. This allows Objective-C to leverage the huge existing collection of C code, libraries, tools, and mindshare. Existing C libraries — even in object code libraries — can be wrapped in Objective-C [[Adapter pattern|wrappers]] to provide an OO-style interface.<br>

* {{cita web | 1 = http://www.devapp.it/wordpress/diventare-un-xcoder.html | 2 = Diventare un XCoder, guida introduttiva sullo sviluppo in Objective C per Mac OS X / iOS | accesso = 28 febbraio 2011 | urlarchivio = https://web.archive.org/web/20110223223634/http://www.devapp.it/wordpress/diventare-un-xcoder.html | dataarchivio = 23 febbraio 2011 | urlmorto = sì }}

All of these practical changes lowered the [[Barriers to entry|barrier to entry]], likely the biggest problem for the widespread acceptance of Smalltalk in the 1980s.

* {{cita web|1=https://developer.apple.com/documentation/Cocoa/Conceptual/ObjectiveC/|2=Introduction to The Objective-C Programming Language (Apple Developer Connection)|lingua=en|accesso=3 maggio 2019|dataarchivio=4 luglio 2003|urlarchivio=https://web.archive.org/web/20030704024148/http://developer.apple.com/documentation/Cocoa/Conceptual/ObjectiveC/ObjC.pdf|urlmorto=sì}}* {{en}}

* {{cita web|1=http://www.toodarkpark.org/computers/objc/|2=Object-Oriented Programming and The Objective-C Language|lingua=en|accesso=6 febbraio 2008|urlarchivio=https://web.archive.org/web/20041018235301/http://www.toodarkpark.org/computers/objc/|dataarchivio=18 ottobre 2004|urlmorto=sì}}

The first versions of Objective-C did not support [[garbage collection (computer science)|garbage collection]]. At the time this decision was a matter of some debate, and many people considered long "dead times" (when Smalltalk did collection) to render the entire system unusable. Although some 3rd party implementations have added this feature (most notably GNUstep), Apple implemented it as of [[Mac OS X v10.5]]. But it is unavailable to applications targeting older versions of the Mac OS<ref>{{cite web|url=http://www.apple.com/macosx/developertools/xcode.html|title=Mac OS X Leopard – Xcode 3.0|author=Apple, Inc.|year=[[August 22]] [[2006]]|=publisher=apple.com|accessdate=2006-08-22}}</ref>

* {{cita web|https://developer.apple.com/documentation/ReleaseNotes/Cocoa/Objective-C++.html|The Objective-C++ Front End|lingua=en}}

* {{cita web|1=http://www.otierney.net/objective-c.html|2=Beginner's Guide to Objective-C|lingua=en|accesso=6 febbraio 2008|urlarchivio=https://web.archive.org/web/20060212231701/http://www.otierney.net/objective-c.html|dataarchivio=12 febbraio 2006|urlmorto=sì}}

Another common criticism is that Objective-C does not have language support for [[Namespace (computer science)|namespaces]]. Instead programmers are forced to add prefixes to their class names, which can cause collisions. As of [[2007]], all Mac OS X classes and functions in the [[Cocoa (software)|Cocoa]] programming environment are prefixed with "NS" (as in NSObject or NSButton) to clearly identify them as belonging to the Mac OS X core; the "NS" derives from the names of the classes as defined during the development of [[NeXTSTEP]].

* {{cita web|http://objectivelib.sourceforge.net/|ObjectiveLib: variant of a Standard Template Library|lingua=en}}

* {{cita web|1=http://virtualschool.edu/objectivec/|2=Objective-C by Brad Cox|lingua=en|accesso=6 febbraio 2008|urlarchivio=https://web.archive.org/web/20120204044211/http://virtualschool.edu/objectivec/|dataarchivio=4 febbraio 2012|urlmorto=sì}}

Since Objective-C is a strict superset of C, it does not treat C primitive types as [[first-class object]]s either.

* {{cita web|1=http://www.cs.indiana.edu/classes/c304/oop-intro.html|2=Object Oriented Programming in Objective-C|lingua=en|accesso=6 febbraio 2008|urlarchivio=https://web.archive.org/web/20090227162548/http://www.cs.indiana.edu/classes/c304/oop-intro.html|dataarchivio=27 febbraio 2009|urlmorto=sì}}

* {{cita web|http://www.faqs.org/faqs/computer-lang/Objective-C/faq/|Objective-C FAQ|lingua=en}}

Unlike [[C++]], Objective-C does not support [[operator overloading]]. Also unlike C++, Objective-C allows an object only to directly inherit from one class (forbidding [[multiple inheritance]]). As Java was influenced by the design of Objective-C, the decision to use single inheritance was carried into Java. Categories and protocols may be used as alternative functionality to multiple inheritance; Java however lacks categories.

* {{cita web|1=http://thaesofereode.info/clocFAQ/|2=comp.lang.objective-C FAQ|lingua=en|accesso=6 febbraio 2008|urlarchivio=https://web.archive.org/web/20090220060852/http://thaesofereode.info/clocFAQ/|dataarchivio=20 febbraio 2009|urlmorto=sì}}

* {{cita web|1=http://www.foldr.org/~michaelw/objective-c/|2=Objective-C: Links, Resources, Stuff|lingua=en|accesso=6 febbraio 2008|dataarchivio=15 giugno 2006|urlarchivio=https://web.archive.org/web/20060615145345/http://www.foldr.org/~michaelw/objective-c/|urlmorto=sì}}

=== Philosophical differences between Objective-C and C++ ===

* {{cita web|url=http://softtecharticles.com/mambo/index.php?option=com_content&task=view&id=32&Itemid=40|titolo=Objective-C A beginners tutorial|lingua=en|urlmorto=sì}}

The design and implementation of [[C++]] and Objective-C represent different approaches to extending C.

* {{en}} [news://comp.lang.objective-c Newsgroup su Objective-C]

* {{cita web|1=http://www.excelsoftware.com/uml_for_objectivec.pdf|2=UML for Objective-C|lingua=en|accesso=6 febbraio 2008|urlarchivio=https://web.archive.org/web/20071128062317/http://www.excelsoftware.com/uml_for_objectivec.pdf|dataarchivio=28 novembre 2007|urlmorto=sì}}

In addition to C’s style of procedural programming, C++ directly supports [[object-oriented programming]], [[generic programming]], and [[metaprogramming]]. C++ also comes with a large standard library which includes several [[Container (data structure)|container classes]]. Objective-C, on the other hand, adds only object-oriented features to C. Objective-C in its purest fashion does not contain the same number of standard library features, but in most places where Objective-C is used, it is used with an [[OpenStep]]-like library such as [[OPENSTEP]], [[Cocoa (API)|Cocoa]], or [[GNUstep]] which provide similar functionality to some of C++’s standard library.

One notable difference is that Objective-C provides runtime support for some [[reflection (computer science)|reflective]] features, whereas C++ adds only a small amount of runtime support to C. In Objective-C, an object can be queried about its own properties, for example whether it will respond to a certain message. In C++ this is not possible without the use of external libraries; however, it is possible to query whether two objects are of the same type (including built-in types) and whether an object is an instance of a given class (or [[superclass (computer science)|superclass]]).

The use of reflection is part of the wider distinction between dynamic (run-time) features versus static (compile-time) features of a language. Although Objective-C and C++ each employ a mix of both features, Objective-C is decidedly geared toward run-time decisions while C++ is geared toward compile-time decisions. The tension between dynamic and static programming involves many of the classic trade-offs in computer science.

-->

==Bibliografia==

*''Object Oriented Programming: An Evolutionary Approach'', Brad J. Cox - Addison Wesley (1991)

==Altri progetti==

{{Interprogetto|b=Objective-C}}

==Collegamenti esterni==

*{en} [http://developer.apple.com/documentation/Cocoa/Conceptual/ObjectiveC/ Introduction to The Objective-C Programming Language (Apple Developer Connection)]

*{en} ''[http://developer.apple.com/documentation/Cocoa/Conceptual/ObjectiveC/ObjC.pdf The Objective-C Programming Language]'', PDF download from Apple

*{en} [http://www.toodarkpark.org/computers/objc/ Object-Oriented Programming and The Objective-C Language]

*{en} [http://developer.apple.com/documentation/ReleaseNotes/Cocoa/Objective-C++.html The Objective-C++ Front End]

*{en} [http://www.otierney.net/objective-c.html Beginner’s Guide to Objective-C]

*{en} [http://objectivelib.sourceforge.net/ ObjectiveLib: variant of a Standard Template Library]

*{en} [http://virtualschool.edu/objectivec/ Objective-C by Brad Cox]

*{en} [http://www.cs.indiana.edu/classes/c304/oop-intro.html Object Oriented Programming in Objective-C]

*{en} [http://www.faqs.org/faqs/computer-lang/Objective-C/faq/ Objective-C FAQ]

*{en} [http://thaesofereode.info/clocFAQ/ comp.lang.objective-C FAQ]

*{en} [http://www.foldr.org/~michaelw/objective-c/ Objective-C: Links, Resources, Stuff]

*{en} [http://softtecharticles.com/mambo/index.php?option=com_content&task=view&id=32&Itemid=40 Objective-C A beginners tutorial]

*{en} [news://comp.lang.objective-c Objective-C mailing list]

*{en} [http://www.excelsoftware.com/uml_for_objectivec.pdf UML for Objective-C] (PDF)

{{Linguaggio C}}

{{Principali linguaggi di programmazione}}

{{Controllo di autorità}}

{{Portale|informatica}}

[[Categoria:LinguaggiObjective-C| di programmazione]]

[[bg:Objective-C]]

[[cs:Objective-C]]

[[da:Objective-C]]

[[de:Objective-C]]

[[en:Objective-C]]

[[eo:Objective-C]]

[[es:Objective-C]]

[[fi:Objective-C]]

[[fr:Objective C]]

[[hu:Objective-C]]

[[ja:Objective-C]]

[[ko:오브젝티브-C]]

[[nl:Objective-C]]

[[no:Objective-C]]

[[pl:Objective-C]]

[[pt:Objective-C]]

[[ru:Objective-C]]

[[sk:Objective-C]]

[[sv:Objective-C]]

[[tg:Objective-C]]

[[th:ภาษาอ็อบเจกทีฟซี]]

[[tr:Objective-C]]

[[uk:Objective C]]

[[zh:Objective-C]]