Д. Стефенс - C++. Сборник рецептов

friend self operator&(self x, const self& y) { return x &= y; }

friend self operator|(self x, const self& y) { return x |= y; }

// операторы сравнения

friend bool operator==(const self& x, const self& y) {

return x.bits == y.bits;

}

friend bool operator!=(const self& x, const self& y) {

return x.bits ! = y.bits;

}

friend bool operator>(const self& x, const self& y) {

return bitsetGt(x.bits, y.bits);

}

friend bool operator<(const self& x, const self& y) {

return bitsetLt(x.bits, y.bits);

}

friend bool operator>=(const self& x, const self& y) {

return bitsetGtEq(x.bits, y.bits);

}

friend bool operator<=(const self& x, const self& y) {

return bitsetLtEq(x bits, y.bits);

}

private:

std::bitset bits;

};

#endif

Шаблонный класс BigIntможно использовать для вычисления факториалов, как показано в примере 11.39.

Пример 11.39. Применение класса big_int

#include "big_int.hpp"

#include

#include

#include

#include

using namespace std;

void outputBigInt(BigInt<1024> x) {

vector v;

if (x == 0) {

cout << 0;

return;

}

while (x > 0) {

v.push_back((x % 10).to_ulong());

x /= 10;

}

copy(v.rbegin(), v.rend(), ostream_iterator(cout, ""));

cout << endl;

}

int main() {

BigInt<1024> n(1); // вычислить факториал числа 32

for (int 1=1; i <= 32; ++i) {

n *= i;

}

outputBigInt(n);

}

Программа примера 11.39 выдает следующий результат.

263130836933693530167218012160000000

Большие целые числа часто встречаются во многих приложениях. Например, в криптографии нередки числа, которые представляются 1000 и более битами. Однако современный стандарт C++ позволяет работать как максимум с типом long int.

Число бит типа long intзависит от реализации, но оно не может быть меньше 32. И едва ли это число будет больше 1000. Следует помнить, что один из этих битов используется в качестве знака.

Ожидается, что новая версия стандарта (C++0x) последует за стандартом C99 и предусмотрит тип long long, размер которого будет, по крайней мере, не меньше размера long int, а возможно, и больше. Несмотря на это, всегда будут случаи, когда требуется наличие целочисленного типа, размер которого превышает размер самого большого встроенного типа.

Представленная здесь реализация основана на двоичном представлении чисел при помощи класса bitset, причем это делается за счет некоторого снижения производительности. Однако я потерял в производительности значительно меньше, чем выиграл в простоте. Более эффективная реализация чисел произвольной точности настолько обширна, что могла бы легко заполнить всю книгу.

Рецепт 11.19.

Требуется обеспечить выполнение вычислений с вещественными числами, используя тип с фиксированной, а не с плавающей точкой.

В примере 11.40 представлена реализация вещественного числа с фиксированной точкой, когда количество двоичных позиций справа от точки задается параметром шаблона. Например, тип basic_fixed_real<10>имеет 10 двоичных цифр справа от двоичной точки, что позволяет представлять числа с точностью до 1/1024.

Пример 11.40. Представление вещественных чисел, используя формат с фиксированной точкой

#include

using namespace std;

template

struct BasicFixedReal {

typedef BasicFixedReal self;

static const int factor = 1 << (E - 1);

BasicFixedReal() : m(0) {}

BasicFixedReal(double d) : m(static_cast(d * factor)) {}

self& operator+=(const self& x) { m += x.m; return *this; }

self& operator-=(const self& x) { m -= x.m; return *this; }

self& operator*=(const self& x) { m *= x.m; m >>=E; return *this; }

self& operator/=(const self& x) { m /= x.m; m *= factor; return *this; }

self& operator*=(int x) { m *= x; return *this; }

self& operator/=(int x) { m /= x; return *this; }

self operator-() { return self(-m); }

double toDouble() const { return double(m) / factor; }

// дружественные функции

friend self operator+(self x, const self& v) { return x += y; }

friend self operator-(self x, const self& y) { return x -= y; }

friend self operator-(self x, const self& y) { return x *= y; }

friend self operator/(self x, const self& y) { return x /= y; }

// операторы сравнения

friend bool operator==(const self& x, const self& y) { return x.m == y.m; }

friend bool operator!=(const self& x, const self& y) { return x.m != y.m; }

friend bool operator>(const self& x, const self& y) { return x.m > y.m; }

friend bool operator<(const self& x, const self& y) { return x.m < y.m; }

friend bool operator>=(const self& x, const self& y) { return x.m >= y.m; }

friend bool operator<=(const self& x, const self& y) { return x.m <= y.m; }

private:

int m;

};

typedef BasicFixedReal<10> FixedReal;

int main() {

FixedReal x(0);

for (int i=0; i < 100; ++i) {

x += FixedReal(0.0625);

}

cout << x.toDouble() << endl;

}

Программа примера 11.40 выдает следующий результат.

6.25

Число с фиксированной точкой, как и число с плавающей точкой, является приблизительным представлением вещественного числа. Число с плавающей точкой имеет мантиссу ( m ) и экспоненту ( е ), обеспечивая значение, вычисляемое по формуле m*b е , где b — некоторая константа.

Число с фиксированной точкой имеет почти такой же формат, но здесь экспонента также фиксирована. Эта константа в примере 11.40 передается шаблону basic_fixed_realв качестве его параметра.

Представление экспоненты е в виде константы позволяет реализовать числа с фиксированной точкой с помощью целых типов и выполнять арифметические операции с ними, используя целочисленную арифметику. Во многих случаях это может повысить скорость выполнения основных арифметических операций, особенно сложения и вычитания.

Представление с фиксированной точкой менее гибко, чем представление чисел с плавающей точкой, так как оно обеспечивает только узкий диапазон значений. Приведенный в примере 11.40 тип fixed_realпозволяет представлять значения только в диапазоне от -2 097 151 до +2 097 151 с точностью 1/1024.

Сложение и вычитание чисел с фиксированной точкой реализуется достаточно естественно: я просто складываю или вычитаю их целочисленные представления. Для выполнения деления и умножения требуется дополнительная операция сдвига мантиссы влево или вправо, чтобы двоичная точка заняла правильную позицию.

В данной главе даются рецепты написания многопоточных программ на C++ с использованием библиотеки Boost Threads, автором которой является Вильям Кемпф (William Kempf). Boost — это набор переносимых, высокопроизводительных библиотек с открытым исходным кодом, неоднократно проверенным программистами, и с широким спектром сложности: от простых структур данных до сложного фреймворка синтаксического анализа. Библиотека Boost Threads обеспечивает фреймворк для многопоточной обработки. Дополнительную информацию по проекту Boost можно найти на сайте www.boost.org .