C ++ Najlepszy sposób na dzielenie liczb całkowitych i resztę

Zastanawiam się tylko, czy chcę podzielić a przez b i interesuje mnie zarówno wynik c, jak i reszta (np. Powiedz, że mam liczbę sekund i chcę to podzielić na minuty i sekundy), jaki jest najlepszy sposób, aby zająć się tym?

Czy może być

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

lub

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

lub

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

lub

może istnieje magiczna funkcja, która daje jedno i drugie na raz?

Na x86 reszta jest produktem ubocznym samego dzielenia, więc każdy w połowie przyzwoity kompilator powinien być w stanie po prostu go użyć (i nie wykonywać divponownie). Prawdopodobnie dzieje się tak również na innych architekturach.

Instrukcja: DIVsrc

Uwaga: Podział bez znaku. Dzieli akumulator (AX) przez „src”. Jeśli dzielnik jest wartością bajtową, wynik jest umieszczany w AL, a reszta do AH . Jeśli dzielnik jest wartością słowa, to DX: AX jest dzielone przez "src" i wynik jest zapisywany w AX, a reszta w DX .

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

std::div zwraca strukturę zawierającą zarówno wynik, jak i resztę.

Przynajmniej na x86 g ++ 4.6.1 po prostu używa IDIVL i pobiera oba z tej pojedynczej instrukcji.

Kod C ++:

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

Kod x86:

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

Przykładowy kod testujący div () i połączony podział i mod. Skompilowałem je za pomocą gcc -O3, musiałem dodać wywołanie doNothing, aby zatrzymać kompilator przed optymalizacją wszystkiego (wyjście byłoby 0 dla rozwiązania dzielenia + mod).

Dodaj szczyptę soli:

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

Wyjścia: 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);
}

Wyjścia: 25

Oprócz wspomnianego std :: div rodziny funkcji, istnieje również std :: remquo rodzina funkcji, zwróci rem -ainder i uzyskiwanie quo -tient za pośrednictwem przekazywane w wskaźnika.

[Edytuj:] Wygląda na to, że std :: remquo w rzeczywistości nie zwraca ilorazu .

Mając wszystko inne na równi, najlepszym rozwiązaniem jest takie, które jasno wyraża Twoje zamiary. Więc:

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

jest prawdopodobnie najlepszą z trzech przedstawionych przez Ciebie opcji. Jak zauważono w innych odpowiedziach, divmetoda obliczy dla Ciebie obie wartości naraz.

Nie możesz ufać g ++ 4.6.3 tutaj z 64-bitowymi liczbami całkowitymi na 32-bitowej platformie Intel. a / b jest obliczane przez wywołanie divdi3, a% b jest obliczane przez wywołanie moddi3. Mogę nawet wymyślić przykład, który oblicza a / b i ab * (a / b) z tymi wywołaniami. Więc używam c = a / b i ab * c.

Metoda div wywołuje funkcję, która oblicza strukturę div, ale wywołanie funkcji wydaje się nieefektywne na platformach, które mają sprzętową obsługę typu integralnego (tj. 64-bitowe liczby całkowite na 64-bitowych platformach intel / amd).

Możesz użyć modułu, aby uzyskać resztę. Chociaż odpowiedź @ cnicutar wydaje się czystsza / bardziej bezpośrednia.