Quelle est la différence entre une constante de chaîne et un littéral de chaîne?

, Quelques définitions

Un littéral est une valeur immuable par définition. par exemple: 10
Une constante est une variable ou un pointeur en lecture seule. par exemple: const int age = 10;
Un chaîne littérale est une expression comme @"". Le compilateur le remplacera par une instance de NSString.
Une constante de chaîne {[31] } est un pointeur en lecture seule sur NSString. par exemple: NSString *const name = @"John";

Quelques commentaires sur la dernière ligne:

• c'est un pointeur constant, pas une constante objet¹. objc_sendMsg² ne se soucie pas si vous vous qualifiez l'objet avec const. Si vous voulez un objet immuable, vous devez coder cette immuabilité à l'intérieur de l'objet³.
• toutes les expressions @"" sont en effet immuables. Ils sont remplacés⁴ au moment de la compilation avec des instances de NSConstantString, qui est une sous-classe spécialisée de NSString avec une disposition de mémoire fixe⁵. Cela explique également pourquoi NSString est le seul objet qui peut être initialisé à la compilation le temps⁶.

Une chaîne constante {[31] } serait const NSString* name = @"John"; ce qui équivaut à NSString const* name= @"John";. Ici, la syntaxe et l'intention du programmeur sont fausses: const <object> est ignoré, et l'instance NSString (NSConstantString) était déjà immuable.

_{¹ Le mot-clé const s'applique s'applique à tout ce qui est immédiatement à sa gauche. Si rien n'est à sa gauche, il s'applique à tout ce qui est immédiatement à sa droite.}

_{² C'est la fonction que le runtime utilise pour envoyer tous les messages dans Objective-C, et donc ce que vous pouvez utiliser pour changer l'état d'un objet.}

_{³ Exemple: en const NSMutableArray *array = [NSMutableArray new]; [array removeAllObjects]; const n'empêche pas la dernière instruction.}

_{⁴ Le code LLVM qui réécrit l'expression est RewriteModernObjC::RewriteObjCStringLiteral dans RewriteModernObjC.rpc.}

_{⁵ Pour voir la NSConstantString définition, cmd+clic dans Xcode.}

_{⁶ la Création de la compilation les constantes pour d'autres classes seraient faciles mais il faudrait que le compilateur utilise une sous-classe spécialisée. Cela casserait la compatibilité avec les anciennes versions D'Objective-C.}

Retour à votre devis

Les frameworks Cocoa s'attendent à ce que les constantes de chaîne globales les littéraux de chaîne sont utilisés pour les clés de dictionnaire, la notification et noms d'exception, et certains paramètres de méthode qui prennent des chaînes. Vous devrait toujours préférer les constantes de chaîne sur les littéraux de chaîne lorsque vous avoir un choix. En utilisant des constantes de chaîne, vous faites appel à l'aide de compilateur pour vérifier votre orthographe et ainsi éviter les erreurs d'exécution.

Il dit que les littéraux sont sujets aux erreurs. Mais il ne dit pas qu'ils sont aussi plus lents. Comparer:

// string literal
[dic objectForKey:@"a"];

// string constant
NSString *const a = @"a";
[dic objectForKey:a];

Dans le second cas, j'utilise des clés avec des pointeurs const, donc à la place [a isEqualToString:b], je peux faire (a==b). L'implémentation de isEqualToString: compare le hachage et exécute ensuite la fonction C strcmp, donc elle est plus lente que comparer les pointeurs directement. Ce qui est pourquoi les chaînes constantes sont meilleures: elles sont plus rapides à comparer et moins sujettes aux erreurs.

Si vous voulez aussi que votre chaîne constante soit globale, faites-le comme ceci:

// header
extern NSString *const name;
// implementation
NSString *const name = @"john";

Utilisons C++, puisque mon objectif C est totalement inexistant.

Si vous stockez une chaîne dans une variable constante:

const std::string mystring = "my string";

Maintenant, quand vous appelez les méthodes, vous utilisez my_string, vous utilisez une constante de chaîne:

someMethod(mystring);

, Ou, vous pouvez appeler ces méthodes avec le littéral de chaîne directement:

someMethod("my string");

La raison, vraisemblablement, qu'ils vous encouragent à utiliser des constantes de chaîne est parce que Objective C ne fait pas "interning"; c'est-à-dire, lorsque vous utilisez le même littéral de chaîne dans plusieurs endroits, c'est en fait un pointeur différent pointant vers une copie séparée de la chaîne.

Pour les clés du dictionnaire, Cela fait une énorme différence, car si je peux voir que les deux pointeurs pointent vers la même chose, c'est beaucoup moins cher que d'avoir à faire une comparaison de chaîne entière pour s'assurer que les chaînes ont une valeur égale.

Edit: Mike, en C # les chaînes sont immuables, et les chaînes littérales avec des valeurs identiques pointent toutes vers la même valeur de chaîne. J'imagine que la vrai pour d'autres langues qui ont des chaînes immuables. Dans Ruby, qui a des chaînes mutables, ils offrent un nouveau type de données: symbols ("foo" vs.: foo, où le premier est une chaîne mutable, et le second est un identifiant immuable souvent utilisé pour les clés de hachage).