/C

# div, ldiv, lldiv, imaxdiv

Defined in header `<stdlib.h>`
`div_t     div( int x, int y );`
(1)
`ldiv_t    ldiv( long x, long y );`
(2)
`lldiv_t   lldiv( long long x, long long y );`
(3) (since C99)
Defined in header `<inttypes.h>`
`imaxdiv_t imaxdiv( intmax_t x, intmax_t y );`
(4) (since C99)

Computes both the quotient and the remainder of the division of the numerator `x` by the denominator `y`.

 Computes quotient and remainder simultaneously. The quotient is the algebraic quotient with any fractional part discarded (truncated towards zero). The remainder is such that `quot * y + rem == x`. (until C99) Computes the quotient (the result of the expression `x/y`) and remainder (the result of the expression `x%y`) simultaneously. (since C99)

### Parameters

 x, y - integer values

### Return value

If both the remainder and the quotient can be represented as objects of the corresponding type (`int`, `long`, `long long`, `imaxdiv_t`, respectively), returns both as an object of type `div_t`, `ldiv_t`, `lldiv_t`, `imaxdiv_t` defined as follows:

## div_t

`struct div_t { int quot; int rem; };`

or.

`struct div_t { int rem; int quot; };`

## ldiv_t

`struct ldiv_t { long quot; long rem; };`

or.

`struct ldiv_t { long rem; long quot; };`

## lldiv_t

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

or.

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

## imaxdiv_t

`struct imaxdiv_t { intmax_t quot; intmax_t rem; };`

or.

`struct imaxdiv_t { intmax_t rem; intmax_t quot; };`

If either the remainder or the quotient cannot be represented, the behavior is undefined.

### Notes

Until C99, the rounding direction of the quotient and the sign of the remainder in the built-in division and remainder operators was implementation-defined if either of the operands was negative, but it was well-defined in `div` and `ldiv`.

On many platforms, a single CPU instruction obtains both the quotient and the remainder, and this function may leverage that, although compilers are generally able to merge nearby `/` and `%` where suitable.

### Example

```#include <assert.h>
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <limits.h>

void reverse(char* first, char* last) {
for (--last; first < last; ++first, --last) {
char c = *last;
*last = *first;
*first = c;
}
}

// demo only: does not check for buffer overflow
char* itoa(int n, int base, char* buf)
{
assert(2 <= base && base <= 16);
div_t dv = {.quot = n};
char* p = buf;
do {
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[100];
printf("%s\n", itoa(0, 2, buf));
printf("%s\n", itoa(007, 3, buf));
printf("%s\n", itoa(12346, 10, buf));
printf("%s\n", itoa(-12346, 10, buf));
printf("%s\n", itoa(-42, 2, buf));
printf("%s\n", itoa(INT_MAX, 16, buf));
printf("%s\n", itoa(INT_MIN, 16, buf));
}```

Possible output:

```0
21
12346
-12346
-101010
7fffffff
-80000000```

### References

• C17 standard (ISO/IEC 9899:2018):
• 7.8.2.2 The imaxdiv function (p: 159)
• 7.22.6.2 The div, ldiv and lldiv functions (p: 259)
• C11 standard (ISO/IEC 9899:2011):
• 7.8.2.2 The imaxdiv function (p: 219)
• 7.22.6.2 The div, ldiv and lldiv functions (p: 356)
• C99 standard (ISO/IEC 9899:1999):
• 7.8.2.2 The imaxdiv function (p: 200)
• 7.20.6.2 The div, ldiv and lldiv functions (p: 320)
• C89/C90 standard (ISO/IEC 9899:1990):
• 4.10 div_t, ldiv_t
• 4.10.6.2 The div function
• 4.10.6.4 The ldiv function

 fmodfmodffmodl (C99)(C99) computes remainder of the floating-point division operation (function) remainderremainderfremainderl (C99)(C99)(C99) computes signed remainder of the floating-point division operation (function) remquoremquofremquol (C99)(C99)(C99) computes signed remainder as well as the three last bits of the division operation (function) C++ documentation for `div`