Ao abrir um código Objective-C pela primeira vez, há algo que chama sua atenção imediatamente.
É a arroba (@), espalhada por todos os lados.
Você escreve @interface, @property e até strings como @“Hello”. No início, pode pensar: “Isso não é um erro de digitação?”
Mas essa @ tem um motivo muito claro.
No Objective-C, @ sinaliza para o compilador: “A partir daqui, isto não é C puro, mas sintaxe de extensão do Objective-C”.
Hoje, vamos explicar de forma simples por que a arroba aparece da mesma maneira em @interface, @property e @“strings”.
Afinal, o que é o @ do Objective-C?
Vamos começar pelo ponto principal.
@ é um símbolo especial que indica ao compilador: “Esta é uma sintaxe exclusiva do Objective-C”.
Para entender isso, é preciso conhecer a origem do Objective-C.
Objective-C não é uma linguagem totalmente nova. É uma linguagem que adiciona recursos orientados a objetos ao C.
Em outras palavras, ela inclui 100% da linguagem C e acrescenta recursos como classes e mensagens.
Mas isso cria um problema.
Para o compilador, é necessário distinguir o que faz parte da sintaxe original do C do que foi acrescentado pelo Objective-C.
O marcador que traça essa linha divisória é justamente o @.
Por que justamente a arroba (@)?
Há o asterisco (*) e o jogo da velha (#), então por que escolher @?
A resposta é surpreendentemente prática.
O símbolo @ não é usado em nenhum lugar da sintaxe padrão da linguagem C.
Vamos relembrar os caracteres usados em C.
- Nomes de variáveis e funções: letras, números e sublinhado (_)
- Operadores: +, -, *, /, =, &, entre outros
- Pré-processador: # (por exemplo, #include)
O @ não aparece em nenhum lugar dessa lista.
Por isso os criadores do Objective-C adotaram o @. Era um símbolo seguro, que nunca entraria em conflito com códigos C existentes.
Se tivessem usado a palavra interface como palavra-chave no lugar de @, todo código C existente que usasse uma variável chamada interface teria quebrado.
Adicionar @ na frente impede esse tipo de conflito desde a origem.
Em uma analogia simples, @ é como o puxador de uma gaveta separada onde ficam as sintaxes exclusivas do Objective-C.
Por que @interface, @property e @“strings” começam todos com @
Agora chegamos ao ponto principal. Vamos entender por que esses três elementos, que parecem diferentes, começam da mesma forma com @.
A conclusão é simples: os três são recursos exclusivos do Objective-C, inexistentes no C.
Vamos analisar um por um.
@interface — Uma diretiva que abre a estrutura, ou declaração, de uma classe. Como C não tem sequer o conceito de classe, foi necessário marcá-la com @. Os correspondentes @implementation e @end existem pelo mesmo motivo.
@property — Um recurso que cria automaticamente a propriedade de um objeto. Como essa sintaxe também não existe no C puro, ela recebe @.
@“strings” — Este é o exemplo mais interessante. “Hello” usando apenas aspas e @“Hello” são coisas completamente diferentes.
Vamos compará-los em uma tabela.
| Categoria | “Hello” | @“Hello” |
|---|---|---|
| O que é | Array de caracteres no estilo C | Objeto NSString |
| Pertence a | Sintaxe original do C | Extensão do Objective-C |
| Função | Uma simples sequência de caracteres | Permite usar métodos como length |
Ao adicionar apenas um @ antes das aspas, um simples bloco de texto se transforma em um “objeto”.
É por isso que o @ é necessário. É como dizer: “Crie esta string como um objeto NSString, e não como uma string C comum”.
Resumindo:
Seja @interface, @property ou @“strings”, todos usam o mesmo marcador @ porque são recursos inexistentes no C e exclusivos do Objective-C.
Veja tudo de uma vez no código
Explicar apenas com palavras pode parecer um pouco abstrato, então preparei um exemplo curto.
Abaixo está uma declaração simples de classe. Observe como @ envolve a sintaxe do Objective-C.
@interface Person : NSObject // Início da declaração da classe (CSintaxe inexistente no C)
@property NSString *name; // Geração automática de propriedades
@end // Fim da declaração
NSString *greeting = @"Olá"; // Antes das aspas @ → NSString ObjetoComo você pode ver, todas as linhas que começam com @ são recursos adicionados pelo Objective-C.
Por outro lado, as partes sem @ são sintaxes herdadas diretamente do C.
Assim, basta observar se há @ para identificar imediatamente: “Ah, isto é uma extensão do Objective-C”.
Perguntas frequentes (Q&A)
P. @ é igual ao # do pré-processador?
Não. O # de #include é uma diretiva do pré-processador processada antes da compilação. Já o @ é uma diretiva do compilador Objective-C interpretada diretamente pelo compilador, portanto suas funções são diferentes.
P. Existem muitos outros tipos de @ além desses?
Sim, vários: @protocol, @selector, @try/@catch e @autoreleasepool, entre outros. Na sintaxe mais recente, também é possível criar facilmente arrays com @[], dicionários com @{} e até objetos numéricos como @42.
P. O Swift também tem @, certo?
Isso mesmo. Porém, o significado é um pouco diferente. No Swift, @ é usado principalmente para marcar atributos, como @State e @IBOutlet. A origem é semelhante, mas os usos são diferentes.
As arrobas espalhadas pelo código podem parecer estranhas, mas, quando você entende que elas são a “fronteira entre C e Objective-C”, passam a parecer familiares.
Seguir apenas os @ já mostra exatamente onde começa a sintaxe orientada a objetos. Ao ler código Objective-C, lembrar desse ponto de vista torna tudo muito mais fácil. Bom código!