C ++ La mejor manera de obtener división y resto de enteros

Solo me pregunto, si quiero dividir a por b, y estoy interesado tanto en el resultado c como en el resto (por ejemplo, digo que tengo un número de segundos y quiero dividirlo en minutos y segundos), ¿cuál es la mejor manera de hacerlo?

Podría ser

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

o

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

o

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

o

tal vez hay una función mágica que le da a uno a la vez?

En x86, el resto es un subproducto de la división en sí, por lo que cualquier compilador medio decente debería poder usarlo (y no divvolver a realizarlo ). Probablemente esto también se haga en otras arquitecturas.

Instrucción: DIVsrc

Nota: división sin firmar. Divide el acumulador (AX) por "src". Si el divisor es un valor de byte, el resultado se coloca en AL y el resto en AH . Si el divisor es un valor de palabra, entonces DX: AX se divide por "src" y el resultado se almacena en AX y el resto se almacena en DX .

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

std::div devuelve una estructura con resultado y resto.

En x86 al menos, g ++ 4.6.1 solo usa IDIVL y obtiene ambos de esa única instrucción.

Código C ++:

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

código x86:

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

Ejemplo de prueba de código div () y división y mod combinados. Los compilé con gcc -O3, tuve que agregar la llamada a doNothing para evitar que el compilador optimizara todo (la salida sería 0 para la solución division + mod).

Tómelo con un grano de sal:

#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);
}

Salidas: 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);
}

Salidas: 25

Además de la familia de funciones std :: div antes mencionada , también existe la familia de funciones std :: remquo , devolver el rem -ainder y obtener el quo -tient a través de un puntero pasado.

[Editar:] Parece que std :: remquo realmente no devuelve el cociente después de todo.

En igualdad de condiciones, la mejor solución es aquella que exprese claramente su intención. Entonces:

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

es probablemente la mejor de las tres opciones que presentó. Sin embargo, como se señaló en otras respuestas, el divmétodo calculará ambos valores a la vez.

No puede confiar en g ++ 4.6.3 aquí con enteros de 64 bits en una plataforma Intel de 32 bits. a / b se calcula mediante una llamada a divdi3 y a% b se calcula mediante una llamada a moddi3. Incluso puedo ofrecer un ejemplo que calcule a / by ab * (a / b) con estas llamadas. Entonces uso c = a / by ab * c.

El método div da una llamada a una función que calcula la estructura div, pero una llamada de función parece ineficaz en plataformas que tienen soporte de hardware para el tipo integral (es decir, enteros de 64 bits en plataformas Intel / amd de 64 bits).

Puede usar un módulo para obtener el resto. Aunque la respuesta de @cnicutar parece más limpia / más directa.