std:: div, std:: ldiv, std:: lldiv, std:: 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 , std::intmax_t , respectivement), retourne les deux sous la forme d'un objet de type std::div_t , std::ldiv_t , std::lldiv_t , std::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 { std::intmax_t quot; std::intmax_t rem; };

struct imaxdiv_t { std::intmax_t rem; std::intmax_t quot; };

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

Notes

Jusqu'à ce que le problème CWG 614 soit résolu ( N2757 ), 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 std::div .

Sur de nombreuses plateformes, une seule instruction CPU obtient à 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 % voisines lorsque cela est approprié.

Exemple

#include <cassert>
#include <cmath>
#include <cstdlib>
#include <iostream>
#include <sstream>
#include <string>
std::string division_with_remainder_string(int dividend, int divisor)
{
    auto dv = std::div(dividend, divisor);
    assert(dividend == divisor * dv.quot + dv.rem);
    assert(dv.quot == dividend / divisor);
    assert(dv.rem == dividend % divisor);
    auto sign = [](int n){ return n > 0 ? 1 : n < 0 ? -1 : 0; };
    assert((dv.rem == 0) or (sign(dv.rem) == sign(dividend)));
    return (std::ostringstream() << std::showpos << dividend << " = "
                                 << divisor << " * (" << dv.quot << ") "
                                 << std::showpos << dv.rem).str();
}
std::string itoa(int n, int radix /*[2..16]*/)
{
    std::string buf;
    std::div_t dv{}; dv.quot = n;
    do
    {
        dv = std::div(dv.quot, radix);
        buf += "0123456789abcdef"[std::abs(dv.rem)]; // string literals are arrays
    }
    while (dv.quot);
    if (n < 0)
        buf += '-';
    return {buf.rbegin(), buf.rend()};
}
int main()
{
    std::cout << division_with_remainder_string(369, 10) << '\n'
              << division_with_remainder_string(369, -10) << '\n'
              << division_with_remainder_string(-369, 10) << '\n'
              << division_with_remainder_string(-369, -10) << "\n\n";
    std::cout << itoa(12345, 10) << '\n'
              << itoa(-12345, 10) << '\n'
              << itoa(42, 2) << '\n'
              << itoa(65535, 16) << '\n';
}

+369 = +10 * (+36) +9
+369 = -10 * (-36) +9
-369 = +10 * (-36) -9
-369 = -10 * (+36) -9
12345
-12345
101010
ffff

Voir aussi

Liens externes