div, ldiv, lldiv, imaxdiv

Calcule à la fois le quotient et le reste de la division du numérateur x par le dénominateur y .

Paramètres

Valeur de retour

Si le reste et le quotient peuvent tous deux être représentés comme des objets du type correspondant ( int , long , long long , intmax_t , respectivement), retourne les deux comme un objet de type div_t , ldiv_t , lldiv_t , imaxdiv_t défini comme suit :

struct div_t { int quot; int rem; };

struct div_t { int rem; int quot; };

struct ldiv_t { long quot; long rem; };

struct ldiv_t { long rem; long quot; };

struct lldiv_t { long long quot; long long rem; };

struct lldiv_t { long long rem; long long quot; };

struct imaxdiv_t { intmax_t quot; intmax_t rem; };

struct imaxdiv_t { intmax_t rem; intmax_t quot; };

Si le reste ou le quotient ne peut pas être représenté, le comportement est indéfini.

Notes

Jusqu'à C99, la direction d'arrondi du quotient et le signe du reste dans les opérateurs de division et de reste intégrés étaient définis par l'implémentation si l'un des opérandes était négatif, mais ils étaient bien définis dans div et ldiv .

Sur de nombreuses plateformes, une seule instruction CPU permet d'obtenir à la fois le quotient et le reste, et cette fonction peut tirer parti de cela, bien que les compilateurs soient généralement capables de fusionner les opérations / et % adjacentes lorsque cela est approprié.

Exemple

#include <assert.h>
#include <limits.h>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
void reverse(char* first, char* last)
{
    for (--last; first < last; ++first, --last)
    {
        char c = *last;
        *last = *first;
        *first = c;
    }
}
// renvoie un tampon vide en cas de dépassement de mémoire tampon
char* itoa(int n, int base, char* buf, size_t buf_size)
{
    assert(2 <= base && base <= 16 && buf && buf_size);
    div_t dv = {.quot = n};
    char* p = buf;
    do
    {
        if (!--buf_size)
            return (*buf = '\0'), buf;
        dv = div(dv.quot, base);
        *p++ = "0123456789abcdef"[abs(dv.rem)];
    }
    while(dv.quot);
    if (n < 0)
        *p++ = '-';
    *p = '\0';
    reverse(buf, p);
    return buf;
}
int main(void)
{
    char buf[16];
    printf("%s\n", itoa(0, 2, buf, sizeof buf));
    printf("%s\n", itoa(007, 3, buf, sizeof buf));
    printf("%s\n", itoa(12346, 10, buf, sizeof buf));
    printf("%s\n", itoa(-12346, 10, buf, sizeof buf));
    printf("%s\n", itoa(-42, 2, buf, sizeof buf));
    printf("%s\n", itoa(INT_MAX, 16, buf, sizeof buf));
    printf("%s\n", itoa(INT_MIN, 16, buf, sizeof buf));
}

0
21
12346
-12346
-101010
7fffffff
-80000000

Références

Voir aussi

Liens externes