C ++ Лучший способ получить целочисленное деление и остаток

Мне просто интересно, если я хочу разделить a на b и меня интересует как результат c, так и остаток (например, скажем, у меня есть количество секунд и я хочу разделить его на минуты и секунды), каков наилучший способ пойти об этом?

Будет ли это

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

или

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

или

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

или

может быть, есть волшебная функция, которая дает и то, и другое одновременно?

На x86 остаток является побочным продуктом самого подразделения, поэтому любой полуприличный компилятор должен иметь возможность просто использовать его (и не выполнять divснова). Вероятно, это сделано и на других архитектурах.

Инструкция: DIVsrc

Примечание: беззнаковое деление. Делит аккумулятор (AX) на "src". Если делитель является байтовым значением, результат помещается в AL, а остаток в AH . Если делитель является значением слова, то DX: AX делится на «src», и результат сохраняется в AX, а остаток сохраняется в DX .

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

std::div возвращает структуру с результатом и остатком.

По крайней мере, на x86 g ++ 4.6.1 просто использует IDIVL и получает и то, и другое из этой единственной инструкции.

Код на C ++:

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

x86 код:

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

Пример кода тестирования div () и комбинированного деления и мода. Я скомпилировал их с помощью gcc -O3, мне пришлось добавить вызов doNothing, чтобы остановить компилятор от оптимизации всего (вывод будет 0 для решения с делением + мод).

Отнеситесь к этому с недоверием:

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

Выходы: 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);
}

Выходы: 25

В дополнение к вышеупомянутому станду :: сНа семейству функций, есть также станд :: remquo семейство функций, возвращают бэры -ainder и получение кво -tient через сдавшую в указателе.

[Edit:] Похоже, что std :: remquo на самом деле не возвращает частное .

При прочих равных, лучшее решение - это то, которое четко выражает ваши намерения. Так:

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

вероятно, лучший из трех представленных вами вариантов. Однако, как отмечено в других ответах, этот divметод вычислит для вас оба значения одновременно.

Здесь нельзя доверять g ++ 4.6.3 с 64-битными целыми числами на 32-битной платформе Intel. a / b вычисляется вызовом divdi3, а a% b вычисляется вызовом moddi3. Я даже могу привести пример, который вычисляет a / b и ab * (a / b) с этими вызовами. Поэтому я использую c = a / b и ab * c.

Метод div вызывает функцию, которая вычисляет структуру div, но вызов функции кажется неэффективным на платформах, которые имеют аппаратную поддержку интегрального типа (т.е. 64-битные целые числа на 64-битных платформах Intel / AMD).

Вы можете использовать модуль, чтобы получить остаток. Хотя ответ @cnicutar кажется более чистым / прямым.