C ++ Il modo migliore per ottenere la divisione intera e il resto

Mi chiedo solo, se voglio dividere a per b, e sono interessato sia al risultato ce al resto (ad esempio, diciamo che ho il numero di secondi e voglio dividerlo in minuti e secondi), qual è il modo migliore per farlo?

Sarebbe

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

forse c'è una funzione magica che dà entrambi contemporaneamente?

Su x86 il resto è un sottoprodotto della divisione stessa, quindi qualsiasi compilatore decente dovrebbe essere in grado di usarlo (e non eseguirne di divnuovo). Questo è probabilmente fatto anche su altre architetture.

Istruzioni: DIVsrc

Nota: divisione senza segno. Divide l'accumulatore (AX) per "src". Se divisore è un valore in byte, il risultato viene inserito in AL e il resto in AH . Se divisore è un valore di parola, allora DX: AX viene diviso per "src" e il risultato viene memorizzato in AX e il resto viene memorizzato in DX .

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

std::div restituisce una struttura con sia il risultato che il resto.

Almeno su x86, g ++ 4.6.1 usa solo IDIVL e ottiene entrambi da quella singola istruzione.

Codice C ++:

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

codice x86:

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

Esempio di codice di test div () e divisione e mod. Li ho compilati con gcc -O3, ho dovuto aggiungere la chiamata a doNothing per impedire al compilatore di ottimizzare tutto (l'output sarebbe 0 per la soluzione division + mod).

Prendilo con un pizzico di sale:

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

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

Uscite: 25

Oltre alla già citata std :: div famiglia di funzioni, v'è anche la std :: remquo famiglia di funzioni, restituire il rem -ainder e ottenere il quo -tient tramite un passato-in puntatore.

[Modifica:] Sembra che std :: remquo non restituisca davvero il quoziente, dopotutto.

A parità di condizioni, la soluzione migliore è quella che esprime chiaramente il tuo intento. Così:

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

è probabilmente la migliore delle tre opzioni che hai presentato. Come notato in altre risposte, tuttavia, il divmetodo calcolerà entrambi i valori contemporaneamente.

Non puoi fidarti di g ++ 4.6.3 qui con numeri interi a 64 bit su una piattaforma Intel a 32 bit. a / b è calcolato da una chiamata a divdi3 e a% b è calcolato da una chiamata a moddi3. Posso persino trovare un esempio che calcoli a / be ab * (a / b) con queste chiamate. Quindi uso c = a / be ab * c.

Il metodo div dà una chiamata a una funzione che calcola la struttura div, ma una chiamata di funzione sembra inefficiente su piattaforme che hanno il supporto hardware per il tipo integrale (cioè interi a 64 bit su piattaforme Intel / amd a 64 bit).

Puoi usare un modulo per ottenere il resto. Anche se la risposta di @ cnicutar sembra più pulita / più diretta.