Прогаю давно, но вот застрял.
Задание: 
Опишите функцию умножения двух целых, обработайте ошибку перепол-нения сверху (overflow).

Я сделал вот что:

#include <iostream>
using namespace std;

int multiply (int a, int b)
{
    int x = a*b;
    if (a>0 && b>0 || a<0 && b<0)
    {
        if(x<=0)
            throw "error";                                        
        else
            return x;
    }
    if (a>0 && b<0 || a<0 && b>0)
    {
        if(x>=0)
            throw "error";                                        
        else
            return x;
    }
}

void main()
{
    // Исключение
    int a = 45, b = a;
    try
    {
        for(;;)
        {
            a = multiply(a, a);
            cout<<b<<" * "<<b<<" = "<<a<<endl;
            b = a;
        }
    }

    catch (char*)
    {
        cout<<b<<" * "<<b<<" = "<<a*a<<" - Overflow!";
    }

    cout<<endl;
    system("pause");
}

вопросы:
1) Я правильно понял задание? Если нет, то объясни что тут имелось ввиду.
2) Если да, то тогда как быть в таком случае:
Опишите функцию деления двух целых, обработайте ошибку переполне-ния снизу (underflow).

Спасибо.

Для простоты предположим что у нас 8-битный процессор. В восемь битов "влезает" 256 значений, включая ноль.
200 * 3 = 400 % 256 = 88
600 не поместится в 8 битов, однако даже для целого со знаком и результат и множители будут больше ноля. Твои проверки это пропустят.

Как то надо иначе работать.
Возьмём 200 * 3 в двоичной системе: 
11001000 * 11 = 
(2^7 + 2^6 + 2^3) * (2^1 + 2^0) = 
2^(7 + 1 + 0) + 2^(6 + 1 + 0) + 2^(3 + 1 + 0) =
2^8 + 2^7 + 2^4 =             (По первому же слагаемому видно что результат выходит за границы)
110010000

Как реализовать алгоритм. "Смотрим" какие биты выставлены в единицу у меньшего из множителей и складываем их индексы, начиная с ноля. Полученную сумму запоминаем, допустим в var. Берём второй множитель и смотрим какие биты выставлены у него, походу сравниваем сумму текущего индекса и var с пороговым значением. Для 32 битных целых, не должно выходить за 31.




Деление посложнее будет, как мне кажется 

Леопольд, чего-то не понял насчет сложения в меньшем множителе.
пример для 8 битовых беззнаковых:
умножаю 6 * 32 = 192. влезает.
в битах 110 * 100000 
для 110 => sum = 3
для 100000 на i == 5 во втором цикле получаю: if(rArg & (one << i)) истина, i + sum = 8, т.е. if(i + summ >= bound) истина. и функция скажет, что мол переполнение.

подсмотрел тупое, но вроде работающее решение:



Это сообщение отредактировал(а) 17dufa - 11.12.2009, 17:31

Значит я что-то не продумал. Но, как мне кажется, надо работать со степенями двойки, возможно как-то иначе...

110 * 100000 = (2^2 + 2^1) * (2^5 + 2^1) = 2^(2+5) + 2^(2+1) + 2^(1+5) + 2^(1+1)


Ты прав, с суммой я перемудрил. Видимо, надо сравнивать сумму старших разрядов. Так вроде работает.



Это сообщение отредактировал(а) Леопольд - 11.12.2009, 18:27

Вполне логичное решение.
Надо только профайлером посмотреть что быстрее...

Это сообщение отредактировал(а) Леопольд - 11.12.2009, 18:47

Спасиб мужыки))) Теперь понял))))

А тогда как быть с этим:
Опишите функцию деления двух целых, обработайте ошибку переполне-ния снизу (underflow)?

Это сообщение отредактировал(а) DJVasek - 11.12.2009, 22:10