C ++ Meilleur moyen d'obtenir la division entière et le reste

Je me demande simplement, si je veux diviser a par b, et si je suis intéressé à la fois par le résultat c et le reste (par exemple, disons que j'ai un nombre de secondes et que je veux le diviser en minutes et secondes), quelle est la meilleure façon de allez-y?

Serait-ce

int c = (int)a / b;
int d = a % b;

ou

int c = (int)a / b;
int d = a - b * c;

ou

double tmp = a / b;
int c = (int)tmp;
int d = (int)(0.5+(tmp-c)*b);

ou

peut-être y a-t-il une fonction magique qui donne les deux à la fois?

Sur x86, le reste est un sous-produit de la division elle-même, donc tout compilateur à moitié décent devrait pouvoir simplement l'utiliser (et ne pas en exécuter à divnouveau). Ceci est probablement également fait sur d'autres architectures.

Instruction: DIVsrc

Remarque: division non signée. Divise l'accumulateur (AX) par "src". Si le diviseur est une valeur d'octet, le résultat est placé sur AL et le reste sur AH . Si le diviseur est une valeur de mot, alors DX: AX est divisé par "src" et le résultat est stocké dans AX et le reste est stocké dans DX .

int c = (int)a / b;
int d = a % b; /* Likely uses the result of the division. */

std::div renvoie une structure avec à la fois résultat et reste.

Sur x86 au moins, g ++ 4.6.1 utilise simplement IDIVL et obtient les deux à partir de cette seule instruction.

Code C ++:

void foo(int a, int b, int* c, int* d)
{
  *c = a / b;
  *d = a % b;
}

code x86:

__Z3fooiiPiS_:
LFB4:
    movq    %rdx, %r8
    movl    %edi, %edx
    movl    %edi, %eax
    sarl    $31, %edx
    idivl   %esi
    movl    %eax, (%r8)
    movl    %edx, (%rcx)
    ret

Exemple de test de code div () et division et mod combinés. Je les ai compilés avec gcc -O3, j'ai dû ajouter l'appel à doNothing pour empêcher le compilateur d'optimiser tout (la sortie serait 0 pour la solution division + mod).

Prenez-le avec un grain de sel:

#include <stdio.h>
#include <sys/time.h>
#include <stdlib.h>

extern doNothing(int,int); // Empty function in another compilation unit

int main() {
    int i;
    struct timeval timeval;
    struct timeval timeval2;
    div_t result;
    gettimeofday(&timeval,NULL);
    for (i = 0; i < 1000; ++i) {
        result = div(i,3);
        doNothing(result.quot,result.rem);
    }
    gettimeofday(&timeval2,NULL);
    printf("%d",timeval2.tv_usec - timeval.tv_usec);
}

Sorties: 150

#include <stdio.h>
#include <sys/time.h>
#include <stdlib.h>

extern doNothing(int,int); // Empty function in another compilation unit

int main() {
    int i;
    struct timeval timeval;
    struct timeval timeval2;
    int dividend;
    int rem;
    gettimeofday(&timeval,NULL);
    for (i = 0; i < 1000; ++i) {
        dividend = i / 3;
        rem = i % 3;
        doNothing(dividend,rem);
    }
    gettimeofday(&timeval2,NULL);
    printf("%d",timeval2.tv_usec - timeval.tv_usec);
}

Sorties: 25

En plus de la famille de fonctions std :: div mentionnée ci-dessus , il y a aussi la famille de fonctions std :: remquo , qui retourne le rem -ainder et obtient le quo -tient via un pointeur passé.

[Edit:] Il semble que std :: remquo ne renvoie pas vraiment le quotient après tout.

Toutes choses étant égales par ailleurs, la meilleure solution est celle qui exprime clairement votre intention. Alors:

int totalSeconds = 453;
int minutes = totalSeconds / 60;
int remainingSeconds = totalSeconds % 60;

est probablement la meilleure des trois options que vous avez présentées. Cependant, comme indiqué dans d'autres réponses, la divméthode calculera les deux valeurs pour vous en même temps.

Vous ne pouvez pas faire confiance à g ++ 4.6.3 ici avec des entiers 64 bits sur une plate-forme Intel 32 bits. a / b est calculé par un appel à divdi3 et a% b est calculé par un appel à moddi3. Je peux même proposer un exemple qui calcule a / b et ab * (a / b) avec ces appels. J'utilise donc c = a / b et ab * c.

La méthode div donne un appel à une fonction qui calcule la structure div, mais un appel de fonction semble inefficace sur les plates-formes qui ont un support matériel pour le type intégral (c'est-à-dire des entiers 64 bits sur les plates-formes Intel / AMD 64 bits).

Vous pouvez utiliser un module pour obtenir le reste. Bien que la réponse de @ cnicutar semble plus claire / plus directe.