Objective-C: differenze tra le versioni
Contenuto cancellato Contenuto aggiunto
m Rimuovo dei wikilink errati. |
|||
| (43 versioni intermedie di 22 utenti non mostrate) | |||
Riga 2:
|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 =
|ha_influenzato = [[C++]], [[Swift_(linguaggio_di_programmazione)|Swift]], [[Java_(linguaggio_di_programmazione)|Java]]▼
|influenzato_da =
▲|ha_influenzato = [[C++]], [[
|implementazione_riferimento =
|sistema_operativo = [[Multipiattaforma]]
|lingua =
|licenza =
|sito_web =
}}
'''Objective-C''', spesso citato anche come '''Objective C''' o '''ObjC''' 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 ottanta]] presso la [[Stepstone]] Corporation.▼
▲'''Objective-C'''
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
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]].▼
▲Le estensioni a oggetti con cui Objective
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]].▼
▲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
== Storia ==
Line 35 ⟶ 41:
=== NeXT ===
Nel [[1988]], [[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
In seguito il [[GNU|progetto GNU]] iniziò a lavorare sul clone libero 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. Il run-time GNU Objective C, che è usato dal [[1993]], è stato sviluppato da [[Kresten Krab Thorup]] mentre era studente universitario in [[Danimarca]].
Line 49 ⟶ 55:
=== 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=
==== Garbage collection ====
Line 56 ⟶ 62:
==== 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:
<
@interface Persona: NSObject {
}
Line 63 ⟶ 69:
-(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:
<
Il compilatore traduce questa notazione in chiamate di metodi accessori. L'istruzione precedente è equivalente a:
<
==== Enumerazione veloce ====
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:
<
for (Persona *persona in laGente)
NSLog(@"%@ ha %i anni.", persona.nome, persona.eta);
</syntaxhighlight>
==== Portable Object Compiler ====
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''
== Sintassi ==
Line 86 ⟶ 92:
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:
<
mentre l'azione equivalente in C++ e Java sarebbe espressa da:
<
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 devono essere di metodi predefiniti.
=== Interfacce e implementazioni ===
Line 99 ⟶ 105:
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".
<
//definizione dell'interfaccia: "NomeDellaClasse.h"
Line 122 ⟶ 128:
@end
</syntaxhighlight>
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.
Line 130 ⟶ 136:
La convenzione usata è quella di assegnare il nome al file basandosi sul nome della classe, nell'esempio "NomeDellaClasse.m"
<
//definizione dell'implementazione: "NomeDellaClasse.m"
Line 141 ⟶ 147:
...
}
{
// implementazione
Line 160 ⟶ 166:
@end
</syntaxhighlight>
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:
<
int fai_la_radice_quadrata(int i)
{
return radice_quadrata(i);
}
</syntaxhighlight>
che avrà come prototipo:
<
L'implementazione come metodo diverrà:
<
- (int) fai_la_radice_quadrata:(int) i
{
return [self radice_quadrata: i];
}
</syntaxhighlight>
Un approccio più canonico alla scrittura del metodo sarebbe quello di citare il primo argomento nel nome del selettore:
<
- (int) faiLaRadiceQuadrataDiInt: (int) i
{
return [self radiceQuadrataDiInt:i];
}
</syntaxhighlight>
Questa sintassi può apparire complicata, ma consente di assegnare i nomi ai [[parametro (informatica)|parametri]], ad esempio:
<
- (int) changeColorWithRed:(int) r green:(int) g blue:(int) b
</syntaxhighlight>
può essere invocato così:
<
[myColor changeColorWithRed:5 green:2 blue:6];
</syntaxhighlight>
Le rappresentazioni interne di questi metodi possono variare con le diverse implementazioni di Objective C.
Se
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.
=== Protocolli ===
Objective C è stato esteso da [[NeXT]] per introdurre il concetto di [[
Un protocollo informale è una lista di [[metodo (informatica)|metodi]] che
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.
Line 219 ⟶ 225:
La sintassi
<
@protocol Locking
- (void)lock;
- (void)unlock;
@end
</syntaxhighlight>
indica che esiste un'idea astratta di [[lock]]ing che può essere usata; quando è dichiarata in una definizione di classe
<
@interface NomeClasse : NomeSuperClasse <Locking>
@end
</syntaxhighlight>
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.
=== Tipizzazione dinamica ===
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
Informazioni di tipizzazione statica possono essere aggiunte eventualmente alle variabili. Tali informazioni sono controllate
<
- 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.
Line 245 ⟶ 251:
Dato che Objective C permette l'invio di un messaggio ad un oggetto che potrebbe non rispondere ad esso, l'oggetto può gestire tale messaggio in altri modi. Uno di questi potrebbe consistere nel suo ''inoltro'' (in [[lingua inglese|inglese]]: ''forwarding'') ad un altro oggetto che sia in grado di rispondere. Il forwarding può essere usato per implementare semplicemente alcuni [[design pattern]] quali l'[[Observer pattern]] o il [[Proxy pattern]].
Il [[run-time system]] di Objective C specifica una coppia di metodi della classe <
* metodi di forwarding:
<
- (retval_t) forward:(SEL) sel :(arglist_t) args; // con GCC
- (id) forward:(SEL) sel :(marg_list) args; // con sistemi NeXT/Apple
</syntaxhighlight>
* metodi di azione:
<
- (retval_t) performv:(SEL) sel :(arglist_t) args; // con GCC
- (id) performv:(SEL) sel :(marg_list) args; // con sistemi NeXT/Apple
</syntaxhighlight>
e se un oggetto vuole implementare il forwarding necessita solamente di "[[override|sovrascrivere]]" i metodi di forwarding per definire il proprio comportamento. I metodi di azione <
==== Esempio ====
Line 262 ⟶ 268:
; ''Forwarder.h''
<
#import <objc/Object.h>
Line 275 ⟶ 281:
@end
</syntaxhighlight>
; ''Forwarder.m''
<
#import "Forwarder.h"
Line 307 ⟶ 313:
}
@end
</syntaxhighlight>
; ''Recipient.h''
<
#import <objc/Object.h>
Line 317 ⟶ 323:
- (id) hello;
@end
</syntaxhighlight>
; ''Recipient.m''
<
#import "Recipient.h"
Line 333 ⟶ 339:
@end
</syntaxhighlight>
; main.m
<
#import "Forwarder.h"
#import "Recipient.h"
Line 357 ⟶ 363:
return 0;
}
</syntaxhighlight>
==== Note ====
Line 367 ⟶ 373:
$
Il compilatore segnala ciò che è stato spiegato prima, che <
$ ./a.out
Line 375 ⟶ 381:
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''.
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
I metodi inseriti nelle categorie sono virtualmente parte della classe quando il programma è in esecuzione. Una categoria
Le categorie forniscono una soluzione ai problemi legati alla "fragilità delle classi base" per ciò che concerne i metodi.
Line 385 ⟶ 391:
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.
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]],
==== Esempio ====
Questo esempio costruisce una classe <
; ''Integer.h''
<
#include <objc/Object.h>
Line 402 ⟶ 408:
- (id) integer: (int) _integer;
@end
</syntaxhighlight>
; ''Integer.m''
<
#import "Integer.h"
Line 420 ⟶ 426:
}
@end
</syntaxhighlight>
; ''Arithmetic.h''
<
#import "Integer.h"
Line 430 ⟶ 436:
- (id) sub: (Integer *) subtrahend;
@end
</syntaxhighlight>
; ''Arithmetic.m''
<
#import "Arithmetic.h"
Line 447 ⟶ 453:
}
@end
</syntaxhighlight>
; ''Display.h''
<
#import "Integer.h"
Line 457 ⟶ 463:
- (id) showint;
@end
</syntaxhighlight>
; ''Display.m''
<
#import "Display.h"
Line 481 ⟶ 487:
}
@end
</syntaxhighlight>
; ''main.m''
<
#import "Integer.h"
#import "Arithmetic.h"
Line 505 ⟶ 511:
[num1 showint];
}
</syntaxhighlight>
==== Note ====
Line 512 ⟶ 518:
gcc -x objective-c main.m Integer.m Arithmetic.m Display.m -lobjc
Si può provare ad omettere le linee <
=== Posing ===
Line 525 ⟶ 531:
Ad esempio:
<
@interface CustomNSApplication : NSApplication
@end
Line 537 ⟶ 543:
class_poseAs ([CustomNSApplication class], [NSApplication class]);
</syntaxhighlight>
Questo intercetta ogni invocazione a setMainMenu di NSApplication.
Line 549 ⟶ 555:
Alcuni compilatori, compreso [[GNU Compiler Collection|GCC]], supportano la clausola ''#import'' anche per il linguaggio C; il suo uso viene comunque scoraggiato sulla base del fatto che l'utilizzatore dei file da includere dovrebbe distinguere quali file includere solo una volta da quelli progettati per essere inclusi più volte. Questo onere dovrebbe in teoria essere a carico dell'implementatore del file da includere che può usare la direttiva ''#pragma once'' o usare la [[Include guard|tradizionale tecnica]]:
<
#ifndef H_PERSONA
#define H_PERSONA
// ... contenuto di header.h ...
#endif
</syntaxhighlight>
In questo caso le direttive ''#include'' e ''#import'' diventano equivalenti.
== Altre caratteristiche ==
Objective C ha incluso sin dal suo apparire
* 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.
Line 575 ⟶ 581:
== Analisi del linguaggio ==
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]].
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.
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
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]].
Dato che Objective C è uno stretto [[superinsieme]] del C, non tratta i tipi primitivi del C come [[first-class object]].
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'[[
=== Differenze filosofiche tra Objective C e C++ ===
Line 601 ⟶ 606:
== Bibliografia ==
*
== Altri progetti ==
{{interprogetto|preposizione=sull'}}
== Collegamenti esterni ==
* {{Collegamenti esterni}}
* {{FOLDOC}}
* {{cita web|http://www.devapp.it/wordpress/diventare-un-xcoder.html|Diventare un XCoder, guida introduttiva sullo sviluppo in Objective C per Mac OS X / iOS}}▼
* {{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ì }}
* {{cita web|http://developer.apple.com/documentation/Cocoa/Conceptual/ObjectiveC/|Introduction to The Objective-C Programming Language (Apple Developer Connection)|lingua=en}}▼
▲* {{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ì }}
▲* {{cita web|
* {{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ì}}
* {{cita web|
* {{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ì}}
* {{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ì}}
* {{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}}
* {{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ì}}
* {{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ì}}
* {{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ì}}
{{Linguaggio C}}
| |||