Тип данных complex стандартной библиотеки языка C++
Южно-Сахалинский институт экономики, права и информатики
Кафедра «Компьютерные технологии и системы»
ПОЯСНИТЕЛЬНАЯ ЗАПИСКА
к курсовой
работе
по дисциплине
«Программирование на языке высокого уровня»
на тему: Тип
данных complex стандартной библиотеки языка C++
Руководитель работы
ст. преподаватель кафедры КТиC
Соболев П.Ю.
«____»__________________2009 г.
Исполнитель
студент группы ВТ-21
Мустафин А.С.
«____»__________________2009 г.
Южно-Сахалинск
Южно-Сахалинский институт экономики, права и информатики
Кафедра Компьютерные технологии и системы
УТВЕРЖДЕНО
Зав. кафедрой
________________ Мазур И.К.
З А Д А Н И Е
на выполнение
курсовой работы студенту Мустафину Александру Сергеевичу
. Тема работы: Тип данных complex
стандартной библиотеки языка C++
. Срок сдачи студентом законченного проекта 22 декабря 2009
. Содержание пояснительной записки (перечень подлежащих к разработке
вопросов):
Введение
1. Постановка и анализ задачи, изучение теоретических вопросов темы
. Разработка алгоритмов и типов данных
3. Разработка программного обеспечения
Заключение
Задание принял к исполнению 1 октября 2009 года
(дата, подпись)
Руководитель ____________________________
(подпись)
ПРИМЕЧАНИЕ: Студент предупрежден о том, что при несвоевременном
представлении работы руководителю студент считается не выполнившим график
учебного процесса и не допускается к защите курсовой работы.
Постановка задачи
Задачей курсовой работы является реализация программы для работы с
комплексными числами. Для реализации программы требуется использовать
интегрированную среду разработки Borland C++ Builder 6.0, а также стандартные
типы данных библиотеки VCL.
Цель работы - изучить типы данных complex и продемонстрировать операции над данным типом для
указанной операционной системы. В проекте предполагается реализовать
программу-калькулятор для комплексных чисел.
Разрабатываемая программа выполняет математические и тригонометрические
функции для данного типа.
Для разработки приложения используются следующие программные инструменты:
1. среда разработки Borland C++ Builder,
2. библиотека
классов VCL (Visual Component
Library),
3. функции интерфейса прикладного программирования операционной
системы Windows (Win32 API).
2 Теоретическая часть
В стандартную библиотеку С++ входит шаблонный класс complex<>, предназначенный для работы
с комплексными числами. На всякий случай стоит напомнить, что комплексные числа
состоят из двух частей: вещественной и мнимой. Особое свойство мнимой части
заключается в том, что ее квадрат является отрицательным числом. Иначе говоря,
мнимая часть представляет собой произведение числа и квадратного корня из -1,
обозначаемого символом i.
2.1 Строение
класса complex
Здесь приведены подробные описания всех операций класса complex<>. Обозначение Т задает
параметр шаблона класса complex<>,
то есть тип вещественной и мнимой частей значения complex.
Определения типов
complex::value_type
Тип вещественной и мнимой частей.
Операции создания, копирования и присваивания
complex::complex ()
● Конструктор по умолчанию.
● Создает комплексное значение, в котором вещественная и мнимая
части инициализируются вызовом конструкторов по умолчанию (0 для базовых типов
данных). Это означает, что для базовых типов данных исходные значения
вещественной и мнимой частей равны 0
сотрlex::complex
(const Т& re)
● Создает комплексное значение, в котором вещественная часть равна re, а мнимая часть инициализируется
вызовом конструктора по умолчанию (0 для базовых типов данных).
● Конструктор также определяет автоматическое преобразование типа Т
в complex
complex::complex (const Т& re. const Т& im)
complex программа число комплексный
Создает комплексное значение, в котором вещественная и мнимая части равны
соответственно re и im
complex polar (const Т& rho)polar (const T& rho. const T& theta)
● Обе формы создают и возвращают комплексное число,
инициализированное в полярных координатах.
● Параметр rho
определяет амплитуду.
● Параметр theta
определяет фазовый угол в радианах (по умолчанию 0).
complex conj (const complex& cmplx)
Создает и возвращает комплексное число, инициализируемое сопряжением
другого комплексного числа (то есть числом с противоположным знаком мнимой
части).
complex::complex (const complex& cmplx)
● Копирующий конструктор.
● Создает новое комплексное число как копию cmplx.
● Копирует вещественную и мнимую части.
● Функция определяется в обеих формах: шаблонной и обычной. Таким
образом, конструктор обеспечивает автоматическое преобразование к типу
элементов.
● В специализированных версиях для типов float, double
и long double копирующие конструкторы ограничиваются так, чтобы
небезопасные преобразования (double
и long double в float,
long double в double)
выполнялись явно, а другие преобразования к типу элементов были запрещены:
Листинг1-преобразования
namespace std { template<>
class complex<float>
{;complex(const
complex<double>&);complex(const complex<long double>)&);
// Другие версии копирующих
конструкторов отсутствуют
};
template<> class
complex<double> { public;(const complex<float>&);complex(const
complex<long double>)&);
// Другие версии копирующих
конструкторов отсутствуют
);
template<> class
complex<long double> { public;(const complex<float>&);(const
complex<double>)&);
// Другие версии копирующих
конструкторов отсутствуют
};
}
& complex: :operator= (const complex& cmplx)
● Присваивает значение комплексного числа cmplx.
● Возвращает *this.
● Функция определяется в обеих формах: шаблонной и обычной. Тем
самым обеспечивается автоматическое преобразование к типу элементов (это
относится и к специализированным версиям из стандартной библиотеки С++).
complex& complex: :operator+= (const complex&
cmplx)& complex::operator-- (const complex& cmplx)&
complex::operator*= (const complex& cmplx)& complex: :operator/= (const
complex& cmplx)
● Сложение, вычитание, умножение и деление cmplx и *this с
сохранением результата в *this.
● Операторы возвращают *this.
● Операции определяются в обеих формах: как шаблонные и обычные
функции. Тем самым обеспечивается автоматическое преобразование к типу элементов
(это относится и к специализированным версиям из стандартной библиотеки С++).
Обратите внимание: операторы присваивания - единственные функции, позволяющие
изменить значение существующего объекта complex.
Обращение к данным
Т complex:.real () const
Т real
(const complex& cmplx)complex::imag () constimag (const complex& cmplx)
●Функции возвращают значение вещественной или мнимой части
соответственно.
● Возвращаемое значение не является ссылкой. Это означает, что
функции real() и imag() не могут использоваться для изменения вещественной
или мнимой части числа. Чтобы изменить только вещественную или мнимую часть,
необходимо присвоить объекту complex
новое комплексное число.
Т abs
(const complex& cmplx)
● Возвращает модуль (абсолютное значение) комплексного числа cmplx.
● По формуле вычисляется модуль комплексного числа. Т norm (const complex&
cmplx)
● Возвращает квадрат модуля комплексного числа cmplx.
● Квадрат модуля комплексного числа вычисляется по формуле стрlx.real()2 + + cmplx.imag()2.
Т arg
(const complex& cmplx)
● Возвращает фазовый угол представления cmplx в полярных координатах (φ).
● Эквивалент:
atan2(cmplx.imag() .cmplx.real()).
Операции ввода-вывода& operator« (ostream& strm, const complex& cmplx)
● Выводит значение cmplx
в ноток данных strm в формате:
(вещественная_часть , мнимая_часть)
● Возвращает strm.
istream& operator» (istream& strm. complex&
cmplx)
● Читает новое значение из потока данных strm в переменную cmplx.
● Допустимые форматы входных данных:
(вещественная_частъ , мнимая_часть)
(вещественная_часть)
вещественная __часть
● Возвращает strm.
Операторыoperator (const complex& cmplx)
Возвращает cmplx. complex operator (const complex& cmplx)
● Унарное изменение знака.
● Возвращает cmplx
с обратными знаками вещественной и мнимой частей.
complex бинарна я_операция (const complex& cmplx1. const complex& cmplx2) бинарная_операция (const complex& cmplx1. const T& value) бинарная_операция (const T& value, const complex& cmplx2)
● Все формы возвращают комплексный результат выполнения заданной
бинарной операции.
● Параметр бинарная_операция - один из следующих операторов:
operator-operator* operator/
● Если при вызове оператора передается скалярное значение типа
элемента, оно интерпретируется как вещественная часть, а мнимая часть инициализируется
значением по умолчанию для своего типа (0 для базовых типов данных).
bool сравнение (const complex&
cmplx1, const complex& cmplx2)сравнение (const complex& cmplx1. const T& value) сравнение (const T& value, const
complex& cmplx1)
● Возвращает результат сравнения двух комплексных чисел или
комплексного
числа со скалярным значением.
● Параметр сравнение - один из следующих операторов:
operator == operator !=
● Если при вызове оператора передается скалярное значение типа
элемента, оно интерпретируется как вещественная часть, а мнимая часть
инициализируется значением по умолчанию для своего типа (0 для базовых типов
данных).
● Обратите внимание: операторы <, <=, > и >= не
поддерживаются.
Трансцендентные функцииpow (const complex& base, int
exp) pow (const complex& base, const T& exp) pow (const complex&
base, const complex& exp) pow (const T& base, const complex& exp)
● Все формы возвращают результат комплексного возведения base в степень ехр, вычисляемый по
формуле:
exp(exp*log(base))
● Разрывы направлены вдоль отрицательной вещественной полуоси.
● Значение, возвращаемое для pow(0,0), определяется реализацией.
complex exp (const complex& cmplx)
Возвращает результат комплексного возведения числа е в степень cmplx.
complex sqrt (const complex& cmplx)
● Возвращает комплексный квадратный корень из cmplx, находящийся в правой полуплоскости.
● Если аргумент является отрицательным вещественным числом, то
возвращаемое значение находится на положительной мнимой полуоси.
● Разрывы направлены вдоль отрицательной вещественной полуоси. complex log (const complex& cmplx)
● Возвращает комплексный натуральный логарифм cmplx.
● Если cmplx является
отрицательным вещественным числом, то imag(log(cmplx))=PI.
● Разрывы направлены вдоль отрицательной вещественной полуоси, complex log10 (const complex& cmplx)
● Возвращает комплексный десятичный логарифм cmplx.
● Эквивалент:
log(cmplx)/log(10)
● Разрывы направлены вдоль отрицательной вещественной полуоси.
complex sin (const complex& cmplx)cos (const complex&
cmplx) tan (const complex& cmplx) sinh (const complex& cmplx) cosh
(const complex& cmplx) tanh (const complex& cmplx)
● Функции возвращают результаты соответствующих комплексных
тригонометрических операций с cmplx.
Класс complex объявляется в заголовочном файле
<complex>:
#include <complex>
Определение класса complex
в файле <complex> выглядит так:
Листинг 2-Определение класса complex
Namespace std
{
template <class T>
class complex;
}
Параметр шаблона T
задает скалярный тип как вещественной, так и мнимой части комплексного числа.
В стандартную библиотеку С++ включены также три специализированные версии
класса complex для типов float, double
и long double:
Листинг 2-специализированные классы
namespace std {
template<> class
complex<float>;
template<> class complex<double>;
template<> class
complex<long double>;
}
Определения этих типов позволяют выполнять некоторые виды оптимизации и
безопасное преобразование от одного комплексного типа к другому.
.2 Примеры использования класса complex
Следующая программа демонстрирует возможности класса complex по созданию комплексных чисел, их
выводу в разных представлениях и выполнению некоторых типовых операций с
комплексными числами.
Листинг 3-Типовые операции класса complex
// num/complex1.cpp
#include <iostream>
#include <complex> namespace
std; main()
{
/* Комплексное число с вещественной и
мнимой частями
* - Вещественная часть: 4.0
* - Мнимая часть: 3.0
complex<double>
c1(4.0.3.0);
/* Создание комплексного числа в
системе полярных координат
* - Амплитуда: 5.0
* - Фазовый угол: 0.75
*/
complex<float>
c2(polar(5.0.0.75));
// Вывод комплексного числа с
вещественной и мнимой частями
cout « "c1: " « c1 « endl:«
"c2: " « c2 « endl;
// Вывод комплексного числа в
полярных координатах
cout « "c1: magnitude: " «
abs(cl)
« " (squared magnitude: " «
norm(c1) « ") "
« " phase angle: " «
arg(c1) « endl; cout « "c2: magnitude: " « abs(c2)
« " (squared magnitude: " «
norm(c2) « ") " « " phase angle: " « arg(c2) « endl;
// Вывод сопряжений комплексных чисел
cout « "c1 conjugated: " «
conj(c1) « endl;« "c2 conjugated: " « conj(c2) « endl;
// Вывод результата вычисления
cout « "4.4 + c1 * 1.8: " « 4.4 + c1 * 1.8 « endl:
/* Вывод суммы c1 и с2: * - внимание: разные типы!
cout « "c1 + с2:
« c1+
complex<double>(c2.real(),c2.imag()) « endl;
// Прибавление к c1 квадратного корня из c1 и вывод результата
cout « "c1 += sqrt(c1): ' « (c1
+= sqrt(c1)) « endl;
}
Примерный результат выполнения программы выглядит так (точный результат
зависит от реализации некоторых свойств типа double):
c1: (4.3): (3.65844.3.40819): magnitude: 5 (squared
magnitude: 25) phase angle: 0.643501: magnitude: 5 (squared magnitude: 25)
phase angle: 0.75: conjugated: (4.-3): conjugated: (3.65844.-3.40819)
.4 + c1 * 1.8: (11.6.5.4)1 + c2:
(7.65844.6.40819)
c1 += sqrt(c1): (6.12132.3.70711)
Вторая программа в цикле читает два комплексных числа и вычисляет
результат возведения первого числа в степень второго:
Листинг 4-цикл возведения первого числа во второе
// num/complex2.cpp
include <iostream>
#include <complex>
#include <cstdlib>
#include <limits> namespace
std;main()
{<long double> c1. c2; (cin.peek()
!= EOF)
{
// Ввод первого комплексного числа
cout « "complex number c1: ";
cin » c1; (!cin)
{« "input error" «
endl;EXIT_FAILURE;
// Ввод второго комплексного числа cout « "complex
number c2: ";» с2; if (!cin)
{
сout « "input error" «
endl;EXIT_FAILURE:
)(c1 == c2)
{« "c1 and c2 are equal !"
« endl;
}« "c1 raised to the c2: "
« pow(c1.c2) « endl « endl;
// Пропуск оставшейся части строки .ignore(numeric_limits<int>::max().'\n');
}
}
В таблице 1 приведены примеры входных данных и полученных результатов.
Таблица 1- Примеры входных данных.
c1
|
|
C2
|
Результат
|
2
|
|
2
|
c1 raised to c2:
(4,0)
|
|
|
|
|
(16)
|
|
0.5
|
c1 raised to C2:
(4,0)
|
(8,0)
|
|
0.333333333
|
c1 raised to c2:
(2,0)
|
|
|
|
|
0.99
|
|
(5)
|
c1 raised to C2:
(0.95099,0)
|
(0,2)
|
|
2
|
c1 raised to c2:
(-4,4.8984e-16)
|
(1.7,0.3)
|
|
0
|
c1 raised to c2:
(1,0)
|
(3,4)
|
|
(-4,3)
|
c1 raised to c2:
(4.32424e-05,8.91396e-05)
|
|
|
|
|
(1.7,0.3)
|
|
(4.3,2.8)
|
c1 raised to c2:
(-4.17622,4.86871)
|
Обратите внимание: при вводе комплексного числа указывается либо только
вещественная часть в виде отдельного значения (в круглых скобках или без), либо
вещественная и мнимая части в круглых скобках, разделенные запятыми.
.3 Операции с комплексными числами
Далее описаны операции с комплексными числами, поддерживаемые классом complex.
В таблице 2 перечислены конструкторы и операции присваивания для типа complex. Конструкторам могут передаваться
исходные значения вещественной и мнимой частей. Если значения не заданы, они
инициализируются конструктором по умолчанию для соответствующего типа.
Таблица 2 - Конструкторы и операции присваивания для типа complex.
Выражение
|
Эффект
|
complex с
|
Создает комплексное число с
нулевой вещественной и мнимой частями (0+0i)
|
complex с(1.3)
|
Создает комплексное число с
вещественной частью 1.3 и нулевой мнимой частью (1.3+0i)
|
complex с(1.3, 2.4)
|
Создает комплексное число с
вещественной частью 1.3 и мнимой частью 4.2 (1.3+4.2i)
|
complex c1(c2)
|
Создает комплексное число c1
как копию с2
|
polar(4.2)
|
Создает временное
комплексное число по полярным координатам (амплитуда р = 4.2, фазовый угол φ = 0)
|
polar(4.2, 0.75)
|
Создает временное
комплексное число по полярным координатам (амплитуда р = 4.2, фазовый угол φ = 0.75)
|
conj(c)
|
Создает временное
комплексное число, сопряженное с числом с (то есть комплексное число с
противоположным знаком мнимой части)
|
c1 = с2
|
Присваивает c1
вещественную и мнимую части с2
|
c1 += с2
|
Прибавляет с2 к c1
|
c1 -= с2
|
Вычитает с2 из c1
|
c1*=c2
|
Умножает с1 на с2
|
с1/=с2
|
Делит с1 на с2
|
Значение существующего комплексного числа может быть изменено только при
помощи операторов присваивания. Комбинированные операторы присваивания +=, -=,
*= и /= осуществляют суммирование, вычитание, умножение и деление значений двух
комплексных операндов.
Вспомогательная функция polar()
позволяет создать комплексное число, инициализируемое в полярных координатах
(через амплитуду и фазовый угол, указанный в радианах):
// Создание комплексного числа с инициализацией в полярных координатах std::complex<double>
c2(std::polar(4.2.0.75));
Если в создании комплексного числа задействовано неявное преобразование
типа, возникает проблема. Например, следующее решение работает нормально: std::complex<float>
c2(std::polar(4.2,0.75)); // OK
Однако похожая запись со знаком равенства ошибочна:
std::complex<float>
с2 =
std::polar(4.2.0.75); // ОШИБКА
Эта проблема рассматривается далее.
Вспомогательная функция conj()
позволяет создать комплексное число, инициализированное значением, сопряженным
с другим комплексным числом (то есть комплексным числом с противоположным
знаком мнимой части):
std: :complex<double> с1(1.1.5.5);::complex<double> c2(conj(c1));
// c2 инициализируется как
// complex<double>(1.1.-5.5)
2.4 Неявные преобразования типов
Конструкторы специализированных версий для типов float double и long double
спроектированы так, чтобы безопасные преобразования типов (например, complex<float> в complex<double>) могли выполняться неявно, а
потенциально рискованные преобразования (например, complex<long double> в complex<double>) были:
std::complex<float> cf;::complex<double>
cd;::complex<long_double> cld;::complex<double> cd1 =cf: //
OK: безопасное преобразование
std::complex<double> cd2 =
сld: // ОШИБКА: нет неявного
преобразования
std::complex<double> cd3(cld); // OK: явное преобразование
He
существует конструкторов, создающих комплексное число по другим комплексным
типам. В частности, нельзя преобразовать complex с целым типом в complex с типом float, double или long double. Впрочем, преобразования можно выполнять при передаче
вещественной и мнимой частей в отдельных аргументах:
std::complex<double> cd;::complex<int>
ci;::complex<double> cd4 = ci; // ОШИБКА: небезопасное преобразование std::complex<double> cd5(ci); // ОШИБКА: нет явного преобразования: :complex<double> cd6(ci.real () .ci .imag()); // OK
К сожалению, операторы присваивания позволяют выполнять небезопасные
преобразования. Они определены в виде шаблонов для всех типов, поэтому
присваивание допустимо для любых комплексных типов (при возможности
пре-образования типа значения):
std: :complex<double> cd;: :complex<long double>
cld;::complex<int> ci;
Эта проблема также относится к функциям polar() и conj().
Например, следующая запись работает нормально:
std::complex<float> c2(std::polar(4.2.0.75)); // OK
С другой стороны, запись со знаком = не работает:
std::complex<float> с2 = std::polar(4.2.0.75); // ОШИБКА
Дело в том, что выражение std::polar(4.2,0.75) создает временный объект complex<double>, а неявное преобразование из complex<double> в complex<float> не определено.
.5 Доступ к данным
В таблице 3 перечислены функции получения атрибутов комплексных чисел.
Таблица 3- Функции получения атрибутов.
Выражение
|
Описание
|
c.real()
|
Возвращает значение
вещественной части (функция класса)
|
real(c)
|
Возвращает значение
вещественной части (глобальная функция)
|
c.lmag()
|
Возвращает значение мнимой
части (функция класса)
|
imag(c)
|
Возвращает значение мнимой
части (глобальная функция)
|
abs(c)
|
Возвращает модуль с ()
|
norm(c)
|
Возвращает квадрат модуля
с(c.real()2+c.imag()2)
|
arg(c)
|
Возвращает фазовый угол в
полярном представлении c(φ); эквивалент atan2(c.imag(),c.real())
|
Функции real() и imag() позволяют только прочитать значения вещественной и
мнимой частей. Чтобы изменить любую из частей комплексного числа, необходимо
присвоить ему новое значение. Например, следующая команда присваивает мнимой
части с значение 3.7: std::complex<double> с;
... с =
std::complex<double>(c.real().3.7);
2.6 Операции сравнения
Из всех операций сравнения для комплексных чисел определены только
проверки на равенство и на неравенство. Операторы == и != определены как
глобальные функции, поэтому один из операндов может быть скалярной величиной. В
этом случае операнд интерпретируется как вещественная часть, а мнимой части
комплексного числа присваивается значение по умолчанию для данного типа (обычно
0).
Другие операции сравнения (например, с оператором < и т. д.) для класса
complex не определены. Хотя в принципе для
комплексных чисел можно определить порядок сортировки, результат получается
недостаточно интуитивным и не приносит особой практической пользы. Например,
сравнивать комплексные числа на основании модулей бессмысленно, поскольку два
разных комплексных числа (например, 1 и -1) могут иметь одинаковые модули.
Конечно, можно изобрести специальный критерий сортировки, например, для двух
комплексных чисел c1 и с2 считать,
что c1<c2 при выполнении условия |c1|<|c2|, а
в случае совпадения модулей - при выполнении условия arg(c1)<arg(c2). Тем не менее такие искусственные критерии не обладают
математическим смыслом.
Таблица 4- Операции сравнения для класса complex<>.
Выражение
|
Описание
|
c1 == c2
|
Проверка на равенство c1
и с2 (c1.real()==c2.real() && c1.imag()==c2.imag())
|
с== 1.7
|
Проверка на равенство c1
и 1.7 (c1.real()==1.7 &&c1.imag()==0.0)
|
1.7 == с
|
с1 != с2
|
Проверка на неравенство c1
и с2 (c1.real()!=c2.real() || c1.imag()!=c2.imag())
|
с != 1.7
|
Проверка на неравенство c1
и 1.7 (c1.real()!=1.7 || c1.imag()!=0.0)
|
1.7 != с
|
Проверка на неравенство 1.7
и с (c1.real()!=1.7 || c1.imag()!=0.0)
|
Из этого следует, что тип complex
не может быть типом элементов ассоциативных контейнеров (без определения
пользовательского критерия сортировки). Дело в том, что для сортировки
элементов по умолчанию ассоциативные контейнеры используют объект функции less<>, который вызывает оператор
<
Определение пользовательского оператора < позволяет сортировать
комплексные числа и использовать их в ассоциативных контейнерах. Нельзя
нарушать стандартное пространство имен. Пример:
Листинг 5-правильное пространство имен
template <class Т>
bool operator< (const std::complex<T>& c1.
const std::complex<T>& c2)
{std::abs(cl)<std;;abs(c2) ||
(std::abs(cl)==std::abs(c2)
&&
std: :arg(cl)<std::arg(c2));
}
.7 Арифметические операции
Для комплексных чисел определены четыре базовые арифметические операции,
а также операции изменения знака.
Таблица 5- Арифметические операции класса complex<>.
Выражение
|
Описание
|
с1+с2
|
Возвращает сумму с1 и с2
|
с1+1.7
|
Возвращает сумму с1 и 1.7
|
1.7 + с
|
Возвращает сумму 1.7 и с
|
c1 - с2
|
Возвращает разность c1
и с2
|
с - 1.7
|
Возвращает разность с и 1.7
|
1.7 - с
|
Возвращает разность 1.7 и с
|
c1 * с2
|
Возвращает произведение c1
и с2
|
с* 1.7
|
Возвращает произведение с и
1.7
|
1.7* с
|
Возвращает произведение 1.7
и с
|
c1 / с2
|
Возвращает частное от
деления c1 на с2
|
с / 1.7
|
Возвращает частное от
деления с на 1.7
|
1.7 / с
|
Возвращает частное от
деления 1.7 на с
|
- с
|
Возвращает значение с с
обратным знаком
|
+ с
|
Возвращает с
|
c1 += с2
|
Эквивалент c1
= c1 + с2
|
c1 -= с2
|
Эквивалент c1
= c1 - с2
|
c1 *= с2
|
Эквивалент c1
= c1 * с2
|
c1 /= с2
|
Эквивалент c1
= c1 / с2
|
2.8 Операции ввода-вывода
В классе complex определены
стандартные операторы ввода-вывода << и >> .
Таблица 6- операции ввода-вывода класса complex<>
Выражение
|
Описание
|
strm << с
|
Записывает комплексное
число с в выходной поток данных strm
|
strm >> с
|
Читает комплексное число с из
входного потока данных strm
|
Оператор “>>” выводит комплексное число в поток данных в следующем
формате:
(вещественная_часть , мнимая_часть)
Эквивалентная реализация оператора вывода выглядит так:
Листинг 6-эквивалентная реализация.
template <class Т. class charT, class traits>
::basic_ostream<charT.traits>& « (std:
:basic_ostream<charT.traits>& strm. const std: :complex<T> c)
{
// Временная строка для выполнения
вывода с одним аргументом
std:
:basic_ostringstream<charT.traits> s:.flags(strm.flags()); // Копирование флагов потока
s.imbue(strm.getloc()); // Копирование локального контеста потока
s.precision(strm.precision()); // Копирование точности потока
// Подготовка итоговой строки
s « '(' « с. real
() « '.' « c.imag() « ')';
// Вывод итоговой строки strm « s.str();
return strm;
}
Оператор ввода читает комплексные числа в одном из представленных ниже
(вещественная_часть, мнимая_часть)
(вещественная_часть)
вещественная_часть
Если очередные символы во входном потоке данных не соответствуют ни
одному из перечисленных форматов, устанавливается флаг ios::failbit,
что может привести к соответствующему исключению.
К сожалению, вы не можете задать собственный разделитель для вещественной
запятой в качестве «десятичной точки» (как, например, в Германии или России)
вводимые/выводимые данные выглядят довольно странно. Например, комплексное
число с вещественной частью 4.6 и мнимой частью 2.7 записывается в виде:
(4.6.2.7).
2.9 Трансцендентные функции
В таблице 7 перечислены трансцендентные функции (тригонометрия,
возведение в степень и т. д.) класса complex.
Таблица 7- Трансцендентные функции.
Выражение
|
Описание
|
pow(c,3)
|
Комплексное возведение в
степень: с3
|
pow(c,1.7)
|
Комплексное возведение в
степень: с1,7
|
pow(с1,c2)
|
Комплексное возведение в
степень: с1c2
|
pow(1.7,c)
|
Комплексное возведение в
степень: 1.7
|
exp(c)
|
Возведение в степень по
основанию е: ес
|
sqrt(c)
|
Квадратный корень из с ()
|
log(c)
|
Комплексный натуральный
логарифм с (In с)
|
log 10(c)
|
Комплексный десятичный
логарифм с (lg с)
|
sln(c)
|
Синус с (sin
с)
|
cos(c)
|
Косинус с (cos
с)
|
tan(c)
|
Тангенс с (tan
с)
|
sinh(c)
|
Гиперболический синус с (sinh
с)
|
cosh(с)
|
Гиперболический косинус с (cosh
с)
|
tanh(c)
|
Гиперболический тангенс с (tanh
с)
|
|
|
|
3 Анализ данных
Для реализации поставленной задачи автором была проведена работа по
анализу входных/выходных данных, используемых в проекте. Общие сведения о
переменных и константах сведены в таблицу. Приводимые в таблицах переменные
представлены в программном коде приложения и сопровождаются комментариями.
Таблица 8 - Входные данные программы.
Переменная
|
Тип
|
Назначение
|
c1
|
complex<long
double>
|
Принимает значение первого
комплексного числа.
|
c2
|
complex<long
double>
|
Принимает значение второго
комплексного числа.
|
Таблица 9 - Выходные данные программы.
Переменная
|
Тип
|
Назначение
|
с
|
AnsiString
|
Формат действительной части
с1, с2.
|
d
|
AnsiString
|
Формат мнимой части с1, с2.
|
Таблица 10 - Промежуточные данные программы.
Переменная
|
Тип
|
Назначение
|
p
|
complex<long double>
|
Полученает значения при
выполнении операций над числами с1 и с2
|
4 Разработка программного обеспечения
Разработка программного обеспечения велась на языке высокого уровня C++,
при использовании перечисленных далее инструментов.
В качестве основного инструмента для разработки программного комплекса на
языке C++ была использована интегрированная среда разработки Borland C++
Builder 6.0. Также при разработке использовались компоненты библиотеки VCL, и
функции, описанные в стандартных заголовочных файлах C++ Builder.
. Назначение программного обеспечения:
Разработанное программное обеспечение является калькулятором для
комплексных чисел, в обязательные функции которого входит:
1. вычисление арифметических функций,
2. вычисление трансцедентных функций,
. операция сравнения.
. Описание реализации функций программы.
.1 Вычисление всех заданных функций и вывод результата.
Для вычисления использовались стандартные функции библиотеки С++ Builder 6.0. Пример реализации операций
описаны ниже:
Листинг 7 - Выполнение вычислений и вывод результата.
{=c1+c2; //Сложение
чисел=FormatFloat("0.00",p.real());=FormatFloat("0.00",p.imag());
//Округление результата до
сотых->Caption="("+c+"."+d+")"; //Вывод
результата сложения
}
. . . . . . . . . . . . . . .
. . . .
{=c1-c2; //Разность
чисел=FormatFloat("0.00",p.real());=FormatFloat("0.00",p.imag());->Caption="("+c+"."+d+")";
}
. . . . . . . . . . . . . . .
. . . . .
{=c1*c2; //Произведение
чисел=FormatFloat("0.00",p.real());=FormatFloat("0.00",p.imag());->Caption="("+c+"."+d+")";
}
. . . . . . . . . . . . . . .
. . . . .
{(c2.real()!=0.0 ||
c2.imag()!=0.0) //Если с2 не равно нулю то
{ //выполнить
деление=c1/c2;=FormatFloat("0.00",p.real());=FormatFloat("0.00",p.imag());->Caption="("+c+"."+d+")";
}//иначе вывести ошибку
{ ShowMessage("Нельзя
делить на ноль");
};
}
4.1 Вывод подсказки использования данной программы
Листинг 8 -Вывод окна помощи.
{
//Вывод сообщение с
подсказкой("Наберите два комплексных числа в данных полях (действительные
и мнимые части каждого числа) и нажмите кнопку 'Ввести',изначально значения
чисел заданы как нулевые. Далее выберите нужную операцию.");
}
5 Руководство пользователя
Представленная программа требует ввода мнимых и действ тельных частей
двух чисел и выбрать нужную операцию, никаких дополнительных действий не
требуется.
Установка программы: специальной установки программа не требует. Для
использования программы необходимо скопировать исполняемый файл в любое место
жёсткого диска. Для работы программы установка дополнительных программных
модулей и библиотек не требуется.
Внешний вид главного окна программы показан на рисунке 1.
Рисунок 1 - главное окно программы
В случае неверно введенных данных будут показаны предупреждения, пример
показан на рисунке 2.
Рисунок 2 - Вывод предупреждения
Заключение
Результатом решения поставленной задачи является программа -калькулятор,
предназначенная для совершений математических операций над комплексными
числами, работающая под управлением операционной системы Windows. Автором
изучены средства работы с комплексным типом данных, предоставленным средой
разработки C++Builder (из библиотеки VCL и интерфейса прикладного
программирования Win32 API).
Стоит отметить тот факт, что в процессе тестирования не выявлены ошибки
времени исполнения, программа полностью реализует заявленные функции и в целом
работает устойчиво.
Так как задачей данной работы являлась демонстрация работы с комплексным
типом стандартной библиотеки C++ Builder 6.0, то на основании выше изложенного
можно утверждать, что тема раскрыта полностью.
Список использованных источников
1. Архангельский,
А.Я. Программирование в С++ Builder 6. [текст] / А. Я. Архангельский -М.:
Бином, 2002. - 1152 с.
2. Дейтел,
Х.М. Как программировать на С++. [текст] / Х.М. Дейтел -М.: Бином, 2001. - 1152
с.
3. Страуструп,
Бьерн Язык программирования С++. [текст] / Бьерн Страуструп -СПб.: Бином, 1999.
- 990 с.: ил.
Приложение
В ходе выполнения курсовой работы было создано программное
приложение-калькулятор. В приложении (носитель: лазерный диск CD-R)
присутствуют следующие файлы:
Файл (каталог)
|
Назначение
|
Curse.exe
|
Файл приложения
|
Проект
|
Папка с исходным проектом в
формате С++ Builder 6
|
записка.doc
|
файл пояснительной записки
|