C ++ Der beste Weg, um Ganzzahldivision und Rest zu erhalten

Ich frage mich nur, ob ich a durch b teilen möchte und sowohl am Ergebnis c als auch am Rest interessiert bin (z. B. wenn ich die Anzahl der Sekunden habe und diese in Minuten und Sekunden aufteilen möchte), was der beste Weg ist mach es?

Wäre es

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

oder

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

oder

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

oder

Vielleicht gibt es eine magische Funktion, die beides gleichzeitig ermöglicht?

Auf x86 ist der Rest ein Nebenprodukt der Division selbst, sodass jeder halbwegs anständige Compiler ihn nur verwenden kann (und kein erneutes ausführen kann div). Dies wird wahrscheinlich auch auf anderen Architekturen durchgeführt.

Anleitung: DIVsrc

Hinweis: Vorzeichenlose Unterteilung. Teilt den Akku (AX) durch "src". Wenn der Divisor ein Bytewert ist, wird das Ergebnis an AL und der Rest an AH gesetzt . Wenn Divisor ein Wortwert ist, wird DX: AX durch "src" geteilt und das Ergebnis wird in AX gespeichert und der Rest wird in DX gespeichert .

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

std::div Gibt eine Struktur mit Ergebnis und Rest zurück.

Zumindest unter x86 verwendet g ++ 4.6.1 nur IDIVL und erhält beide von dieser einzelnen Anweisung.

C ++ - Code:

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

x86-Code:

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

Beispielcode-Test div () und kombinierte Division & Mod. Ich habe diese mit gcc -O3 kompiliert und musste den Aufruf von doNothing hinzufügen, um zu verhindern, dass der Compiler alles optimiert (die Ausgabe wäre 0 für die Division + Mod-Lösung).

Nehmen Sie es mit einem Körnchen Salz:

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

Ausgänge: 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);
}

Ausgänge: 25

Zusätzlich zu den oben genannten std :: div Familie von Funktionen, gibt es auch die std :: remquo Familie von Funktionen, kehren die rem -ainder und bekommen die quo -tient über eine bestandene-in - Zeiger.

[Edit:] Es sieht so aus, als würde std :: remquo den Quotienten doch nicht wirklich zurückgeben .

Wenn alles andere gleich ist, ist die beste Lösung eine, die Ihre Absicht klar zum Ausdruck bringt. So:

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

ist wahrscheinlich die beste der drei von Ihnen vorgestellten Optionen. Wie in anderen Antworten angegeben, divberechnet die Methode jedoch beide Werte gleichzeitig für Sie.

Sie können g ++ 4.6.3 hier mit 64-Bit-Ganzzahlen auf einer 32-Bit-Intel-Plattform nicht vertrauen. a / b wird durch einen Aufruf von divdi3 berechnet und a% b wird durch einen Aufruf von moddi3 berechnet. Ich kann mir sogar ein Beispiel ausdenken, das mit diesen Aufrufen a / b und ab * (a / b) berechnet. Also benutze ich c = a / b und ab * c.

Die div-Methode ruft eine Funktion auf, die die div-Struktur berechnet, aber ein Funktionsaufruf scheint auf Plattformen mit Hardwareunterstützung für den integralen Typ ineffizient zu sein (dh 64-Bit-Ganzzahlen auf 64-Bit-Intel / AMD-Plattformen).

Sie können einen Modul verwenden, um den Rest zu erhalten. Obwohl die Antwort von @ cnicutar sauberer / direkter erscheint.