C division entière et à l'étage

Dans C, il existe une différence entre la division entière de a/b et floor(a/b) où a et b sont des nombres entiers?
Plus précisément ce qui se passe au cours de ces deux processus?

Double Possible de Quel est le comportement de la division entière?

OriginalL'auteur CodeKingPlusPlus | 2012-09-02

  1. 10

    a/b n'division entière. Si a ou b est négatif, le résultat dépend du compilateur (arrondi peut aller vers zéro ou vers l'infini négatif en pré-C99; en C99+, le mode d'arrondi vers 0). Le résultat est de type int. floor(a/b) fait la même division, convertit le résultat en double, supprime le (inexistante) de partie fractionnaire, et renvoie le résultat sous la forme d'un double.

    En C integer division effectue troncature vers zéro. Cela est vrai depuis le C99, avant qu'elle soit mise en œuvre définies.
    Ah, raté le C tag. Pourtant, il est clair que ma réponse est sur le C++. <g>
    le point est que floor n'a pas rond quelque chose dans cet exemple parce que a / b effectue une division entière, et passe à floor.
    J'ai évidemment mal lu la question...
    euh... d'accord?

    OriginalL'auteur Pete Becker

  2. 6

    floor renvoie une double tout a /b où les deux a et b sont des entiers donne une valeur de type entier.

    Avec la bonne fonte de la valeur est la même.

    Si typeof opérateur existé en C (il n'a pas) on aurait:

    (typeof (a /b)) floor(a / b) == a / b

    EDIT: Maintenant, si la question est: quelle est la différence entre:

    (double) (a / b)

    et

    floor(a / (double) b)

    la réponse est oui. Les résultats diffèrent en ce qui concerne les valeurs négatives.

    OriginalL'auteur ouah

  3. 4

    Il est possible de perdre de l'information de la conversion d'entier en virgule flottante. Pas de chances avec int et double, mais avec une légère modification:

    #include <stdio.h>
#include <math.h>

int main(void)
{
    unsigned long long a = 9000000000000000003;
    unsigned long long b = 3;
    printf("a/b = %llu\n", a/b);
    printf("floor(a/b) = %f\n", floor(a/b));
    return 0;
}

    Résultat:

    a/b = 3000000000000000001
floor(a/b) = 3000000000000000000.000000
    Un double peut stocker toutes les valeurs d'entier de 32 bits exactement. Vous pouvez toujours utiliser des doubles au lieu de int. Ce n'est pas seulement peu probable d'une perte de précision, il est impossible. Votre exemple est correct, mais tromper les gens qui ne comprennent pas le problème.

    OriginalL'auteur Alan Curry

  4. 1

    En général, en supposant que les entiers sont représentables dans les deux entier et les types à virgule flottante, il n'y a pas de différence, mais la preuve n'est pas évident. Le problème est qu'en virgule flottante, un arrondissement se produit dans la division a/b, de sorte que le plancher de la fonction ne s'applique pas sur l'exacte valeur rationnelle, mais sur une valeur approximative. J'avais écrit un papier sur le sujet: https://www.vinc17.net/research/publi.html#Lef2005b

    En bref, le résultat que j'ai obtenu, c'est que si a - b est exactement représentable dans le floating-point du système, puis floor(a/b), où a et b sont des nombres à virgule flottante (avec des valeurs entières), donne le même résultat que la division entière de a/b.

    OriginalL'auteur vinc17