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

 1.23456 - НЕ допустимое число двойной точности.

 1.23456 - НЕ допустимое число одинарной точности.

asdf - НЕ допустимое целое число.

asdf - НЕ допустимое число двойной точности.

asdf - НЕ допустимое число одинарной точности.

Шаблон функции lexical_cast преобразует значение из одного типа в другой. Он объявлен следующим образом.

template<typename Target, typename Source>

Target lexical_cast(Source arg)

Source — это тип оригинальной переменной, a Target — это тип переменной, в которую значение преобразуется. Таким образом, например, чтобы преобразовать из string в int, вызов lexical_cast имеет вид:

int i = lexical_cast<int>(str); // str - это строка

lexical_cast проводит анализ и пытается выполнить преобразование. Если преобразование невозможно, он выбрасывает исключение bad_lexical_cast. В примере 3.5 я только хочу проверить допустимость, и мне не требуется сохранять целевую переменную, так что если исключение не выбрасывается, я возвращаю true, а в противном случае — false.

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

int i = lexical_cast<int, string>(str);

Это означает то же самое, но указывать аргумент string не требуется, так как компилятор видит, что str — это string, и понимает, что от него требуется дальше.

Если вы собираетесь написать аналогичную функцию-обертку для проверки допустимости, возвращающую true и false, ее также можно написать как шаблон функции. В этом случае ее потребуется написать только один раз с использованием параметризованного типа, а различные версии будут генерироваться при каждом ее использовании с различными типами.

lexical_cast также удобен для преобразования из одного числового типа в другой. Более подробно это обсуждается в рецепте 3.6.

Рецепт 3.6.

3.4. Сравнение чисел с плавающей точкой с ограниченной точностью

Требуется сравнить значения с плавающей точкой, но при этом выполнить сравнение на равенство, больше чем или меньше чем с ограниченным количеством десятичных знаков. Например, требуется, чтобы 3.33333 и 3.33333333 считались при сравнении с точностью 0.0001 равными.

Напишите свои функции сравнения, которые принимают в качестве параметра ограничение точности сравнения. Пример 3.6 показывает основную методику, используемую в такой функции сравнения.

Пример 3.6. Сравнение чисел с плавающей точкой

#include <iostream>

#include <cmath> // для fabs()

using namespace std;

bool doubleEquals(double left, double right, double epsilon) {

 return (fabs(left - right) < epsilon);

}

bool doubleLess(double left, double right, double epsilon,

 bool orequal = false) {

 if (fabs(left - right) < epsilon) {

  // В рамках epsilon, так что считаются равными

  return (orequal);

 }

 return (left < right);

}

bool doubleGreater(double left, double right, double epsilon,

 bool orequal = false) {

 if (fabs(left - right) < epsilon) {

  // В рамках epsilon, так что считаются равными

 return (orequal);

 }

 return (left > right);

}

int main() {

 double first = 0.33333333;

 double second = 1.0 / 3.0;

 cout << first << endl;

 cout << second << endl;

 // Тест на прямое равенство. Не проходит тогда, когда должно проходить.

 // (boolalpha печатает булевы значения как "true" или "false")

 cout << boolalpha << (first == second) << endl;

 // Новое равенство. Проходит так, как требуется в научном приложении.

 cout << doubleEquals(first, second, .0001) << endl;

 // Новое меньше чем

 cout << doubleLess(first, second, .0001) << endl;

 // Новое больше чем

 cout << doubleGreater(first, second, .0001) << endl;

 // Новое меньше чем или равно

 cout << doubleLess(first, second, .0001, true) << endl;

 // Новое больше чем или равно

 cout << doubleGreater(first, second, .0001, true) << endl;

}

Далее показан вывод этого примера.

0.333333

0.333333

false

true

false

false

true

true

Код примера 3.6 начинается с двух значений — 0.33333333 и того, что компьютер получает в результате деления 1.0 / 3.0. Он с помощью форматирования по умолчанию cout печатает эти два значения. Они кажутся одинаковыми и равными 0.333333. Однако при сравнении этих двух значений они оказываются различными. Значение 1.0 / 3.0 имеет больше значащих цифр, чем 0.33333333, и, следовательно, как полагает машина, эти два числа не равны. Однако в некоторых приложениях может потребоваться, чтобы они считались равными.

Чтобы добиться этого, надо написать собственные функции сравнения чисел с двойной точностью: doubleLess, doubleEquals и doubleGreater, каждая из которых принимает в качестве параметров два значения типа double. Кроме того, doubleLess и doubleGreater имеют дополнительный параметр, который при его равенстве true приводит к тому, что эти функции ведут себя как «меньше или равно» и «больше или равно» соответственно.

Чтобы заставить эти функции учитывать точность, рассмотрим функцию doubleEquals. Вместо того чтобы проверять на равенство, эта функция проверяет, находится ли разность двух чисел в указанном пользователем диапазоне epsilon. (В качестве epsilon пример использует значение 0.0001.) Если это так, то функция возвращает значение true, что означает, что значения одинаковы. Таким образом, равными окажутся значения 0.3333, 0.33333, 0.333333, 0.33333333333 и 0.33333323438.

Чтобы выполнить операцию «меньше чем» и «больше чем», вначале проверьте, не равны ли значения, как это делается в функции doubleEquals. Если так, то при наличии теста на равенство верните true, а в противном случае — false. В противном случае выполните прямое сравнение.

3.5. Лексический анализ строки, содержащей число в экспоненциальной форме

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

Наиболее простым способом анализа числа в экспоненциальной форме является использование встроенного в библиотеку C++ класса stringstream, объявленного в <sstream>, как показано в примере 3.7.

Пример 3.7. Лексический анализ числа в экспоненциальной форме

#include <iostream>

#include <sstream>

#include <string>

using namespace std;

double sciToDub(const strings str) {

 stringstream ss(str);

 double d = 0;

 ss >> d;

 if (ss.fail()) {

  string s = "Невозможно отформатировать ";

  s += str;

  s += " как число!";

  throw (s);

 }

 return (d);

}

int main() {

 try {

  cout << sciToDub("1.234e5") << endl;

  cout << sciToDub("6.02e-2") << endl;

  cout << sciToDub("asdf") << endl;

 } catch (string& e) {

  cerr << "Ошибка: " << e << endl;

 }

}

Далее показан вывод этого кода.

123400

0.0602

Ошибка: невозможно отформатировать asd как число!

Класс stringstream — это string, который ведет себя как поток (что неудивительно). Он объявлен в <sstring>. Если требуется выполнить анализ string, содержащей число в экспоненциальной форме (см. также рецепт 3.2), то с этой работой прекрасно справится stringstream. Стандартные классы потоков уже «знают», как анализировать числа, так что не тратьте без острой необходимости время на повторную реализацию этой логики.

В примере 3.7 я написал простую функцию sciToDub, принимающую параметр типа string и возвращающую содержащийся в ней double, если он допустим. В sciToDub я использую stringstream следующим образом.

stringstream ss(str); // Конструирование из строки типа string

double d = 0;

ss >> d;

if (ss.fail()) {

 string s = "Невозможно отформатировать ";

 s += str;