“F” après nombre / flottant en Objective-C / C

Je ne trouve pas cela dans les documents Apple, alors: qu’est-ce que le “f” après les chiffres indique ici? Est-ce de C ou Objective-C? Y a-t-il une différence dans le fait de ne pas append cela à un nombre constant?

CGRect frame = CGRectMake(0.0f, 0.0f, 320.0f, 50.0f); 

Pouvez-vous expliquer pourquoi je ne voudrais pas simplement écrire:

 CGRect frame = CGRectMake(0, 0, 320, 50); 

 CGRect frame = CGRectMake(0.0f, 0.0f, 320.0f, 50.0f); 

utilise des constantes de type float. (La constante 0.0 déclare généralement un double dans Objective-C; mettre un f à la fin – 0.0f – déclare la constante comme un flottant (32-bit).)

 CGRect frame = CGRectMake(0, 0, 320, 50); 

utilise des ints qui seront automatiquement convertis en flotteurs.

Dans ce cas, il n’y a pas de différence (pratique) entre les deux.

En cas de doute, vérifiez la sortie de l’assembleur. Par exemple, écrivez un petit extrait minimal, par exemple

 #import  void test() { CGRect r = CGRectMake(0.0f, 0.0f, 320.0f, 50.0f); NSLog(@"%f", r.size.width); } 

Ensuite, comstackz-le avec l’assembleur avec l’option -S .

 gcc -S test.m 

Enregistrez la sortie de l’assembleur dans le fichier test.s et supprimez .0f des constantes et répétez la commande de compilation. test.s ensuite un diff des nouveaux test.s et du précédent. Pensez que cela devrait montrer s’il y a de réelles différences. Je pense que trop de gens ont une vision de ce qu’ils pensent du compilateur, mais au bout du compte, il faut savoir vérifier les théories.

Parfois, il y a une différence.

 float f = 0.3; /* OK, throw away bits to convert 0.3 from double to float */ assert ( f == 0.3 ); /* not OK, f is converted from float to double and the value of 0.3 depends on how many bits you use to represent it. */ assert ( f == 0.3f ); /* OK, comparing two floats, although == is finicky. */ 

Il indique à l’ordinateur qu’il s’agit d’un nombre à virgule flottante (je suppose que vous parlez de c / c ++ ici). S’il n’y a pas de f après le nombre, il est considéré comme un double ou un entier (selon qu’il y a une décimale ou non).

 3.0f -> float 3.0 -> double 3 -> integer 

Un littéral à virgule flottante dans votre code source est analysé en double. L’affecter à une variable de type float perd de la précision. Beaucoup de précision, vous jetez 7 chiffres significatifs. Le postfixe “f” vous permet de dire au compilateur: “Je sais ce que je fais, c’est intentionnel. Ne m’embêtez pas”.

Les chances de produire un bug ne sont pas si petites. Beaucoup de programmes se sont penchés sur une comparaison en virgule flottante mal conçue ou supposent que 0.1 est exactement représentable.

Le f dont vous parlez est probablement destiné à indiquer au compilateur qu’il travaille avec un flottant. Lorsque vous omettez le f , il est généralement traduit en double.

Les deux sont des nombres à virgule flottante, mais un float utilise moins de bits (donc plus petit et moins précis) qu’un double .

C’est un truc C – les littéraux à virgule flottante sont double précision (double) par défaut. L’ajout d’un suffixe f en fait une précision unique (float).

Vous pouvez utiliser ints pour spécifier les valeurs ici et dans ce cas cela ne fera aucune différence, mais utiliser le bon type est une bonne habitude à prendre – la cohérence est une bonne chose en général, et si vous avez besoin de changer ces valeurs plus tard sauront à première vue de quel type ils sont.

De C. Cela signifie une constante littérale flottante. Vous pouvez omettre à la fois “f” et “.0” et utiliser ints dans votre exemple en raison de la conversion implicite de ints en flottants.

Il s’agit presque certainement de C et reflète le désir d’utiliser un type «flottant» plutôt qu’un type «double». Il est similaire aux suffixes tels que L sur les nombres pour indiquer qu’ils sont des entiers longs. Vous pouvez simplement utiliser des entiers et le compilateur sera automatiquement converti comme il convient (pour ce scénario spécifique).

Il indique généralement au compilateur que la valeur est un float , c’est-à-dire un entier à virgule flottante. Cela signifie qu’il peut stocker des entiers, des valeurs décimales et des exponentielles, par exemple 1 , 0.4 ou 1.2e+22 .