Diffuser vers int vs sol

Y a-t-il une différence entre ceux-ci:

float foo1 = (int)(bar / 3.0);
float foo2 = floor(bar / 3.0);

Si je comprends bien, les deux cas ont le même résultat. Y a-t-il une différence dans le code compilé?

La conversion en un entier tronquera vers zéro. floor()tronquera vers l'infini négatif. Cela vous donnera des valeurs différentes si elles barétaient négatives.

Comme cela a été dit précédemment, pour les nombres positifs, ils sont identiques, mais ils diffèrent pour les nombres négatifs. La règle est que int arrondit vers 0, tandis que le plancher arrondit vers l'infini négatif.

floor(4.5) = (int)4.5 = 4
floor(-4.5) = -5 
(int)(-4.5) = -4

Cela étant dit, il existe également une différence de temps d'exécution. Sur mon système, j'ai chronométré que le casting est au moins 3 fois plus rapide que le sol.

J'ai du code qui nécessite le fonctionnement au sol d'une plage limitée de valeurs, y compris des nombres négatifs. Et il doit être très efficace, nous utilisons donc la fonction suivante pour cela:

int int_floor(double x) 
{ 
    return (int)(x+100000) - 100000; 
}

Bien sûr, cela échouera pour de très grandes valeurs de x (vous rencontrerez des problèmes de dépassement de capacité) et pour des valeurs négatives inférieures à -100000, etc. pour notre application. Prenez-le avec un grain de sel, testez-le sur votre système, etc. mais cela vaut la peine d'être considéré à mon humble avis.

SO 101, ne changez pas votre question une fois que les gens ont répondu à votre question, écrivez plutôt une nouvelle question.

Pourquoi pensez-vous qu'ils auront le même résultat?

float foo = (int)(bar / 3.0) //will create an integer then assign it to a float

float foo = fabs(bar / 3.0 ) //will do the absolute value of a float division

bar = 1.0

foo1 = 0;
foo2 = 0.33333...

EDIT: Parce que la question peut avoir été modifiée en raison de la confusion entre fabs()et floor().

Compte tenu des lignes d'exemple de question d'origine:

1.  float foo = (int)(bar / 3.0);

2.  float foo = fabs(bar / 3.0);

La différence est que si la barre est négative, le résultat sera négatif avec le premier mais positif avec le second. Le premier sera tronqué à un entier et le second renverra la valeur décimale complète, y compris la partie fractionnaire.

Oui. fabsrenvoie la valeur absolue de son argument, et le transtypage en int provoque la troncature de la division (jusqu'à l'entier le plus proche), de sorte que les résultats seront presque toujours différents.

Il existe deux différences principales:

1. Comme d'autres l'ont souligné, la conversion en un entier tronquera vers zéro, alors que floor()sera toujours tronquée vers l'infini négatif; c'est un comportement différent pour un opérande négatif.

2. Personne (encore) ne semble avoir signalé une autre différence - si votre argument est supérieur ou égal à MAX_INT+1(ou inférieur à -MAX_INT-1), alors la conversion en un intentraînera la suppression des bits les plus hauts (C, probablement) ou un comportement indéfini ( C ++ et éventuellement C). EG si votre intest de 32 bits, vous n'aurez qu'un bit de signe plus 31 bits de données. Donc, utiliser ceci avec un doublequi est de grande taille va produire des résultats inattendus.

(int) xest une requête pour conserver la partie entière de x(il n'y a pas d'arrondi ici)

fabs(x)= | x | pour que ce soit >= 0;

Ex: (int) -3.5retourne -3; fabs(-3.5)retourne 3.5;

En général, fabs (x) >= xpour tout x;

x >= (int) x si x >= 0

x < (int) x si x < 0