Тип данных complex стандартной библиотеки языка C++

Размещено на http://www.allbest.ru/

Размещено на http://www.allbest.ru/

Южно-Сахалинский институт экономики, права и информатики

Кафедра «Компьютерные технологии и системы»

ПОЯСНИТЕЛЬНАЯ ЗАПИСКА

к курсовой работе

по дисциплине «Программирование на языке высокого уровня»

на тему: Тип данных complex стандартной библиотеки языка C++

Руководитель работы

ст. преподаватель кафедры КТиC

Соболев П.Ю.

«____»__________________2009 г.

Исполнитель

студент группы ВТ-21

Мустафин А.С.

«____»__________________2009 г.

Южно-Сахалинск

2009

Южно-Сахалинский институт экономики, права и информатики

Кафедра Компьютерные технологии и системы

УТВЕРЖДЕНО

Зав. кафедрой

________________ Мазур И.К.

З А Д А Н И Е

на выполнение курсовой работы студенту Мустафину Александру Сергеевичу

1. Тема работы: Тип данных complex стандартной библиотеки языка C++

2. Срок сдачи студентом законченного проекта 22 декабря 2009

4. Содержание пояснительной записки (перечень подлежащих к разработке вопросов):

Введение

1. Постановка и анализ задачи, изучение теоретических вопросов темы

2. Разработка алгоритмов и типов данных

3. Разработка программного обеспечения

Заключение

Задание принял к исполнению 1 октября 2009 года

(дата, подпись)

Руководитель ____________________________

(подпись)

ПРИМЕЧАНИЕ: Студент предупрежден о том, что при несвоевременном представлении работы руководителю студент считается не выполнившим график учебного процесса и не допускается к защите курсовой работы.

1 Постановка задачи

Задачей курсовой работы является реализация программы для работы с комплексными числами. Для реализации программы требуется использовать интегрированную среду разработки 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)

complex 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>

{

public;

explicit complex(const complex<double>&);

explicit complex(const complex<long double>)&);

// Другие версии копирующих конструкторов отсутствуют

};

template<> class complex<double> { public;

complex(const complex<float>&);

explicit complex(const complex<long double>)&);

// Другие версии копирующих конструкторов отсутствуют

);

template<> class complex<long double> { public;

complex(const complex<float>&);

complex(const complex<double>)&);

// Другие версии копирующих конструкторов отсутствуют

};

}

complex& complex: :operator= (const complex& cmplx)

? Присваивает значение комплексного числа cmplx.

? Возвращает *this.

? Функция определяется в обеих формах: шаблонной и обычной. Тем самым обеспечивается автоматическое преобразование к типу элементов (это относится и к специализированным версиям из стандартной библиотеки С++).

complex& complex: :operator+= (const complex& cmplx)

complex& complex::operator-- (const complex& cmplx)

complex& complex::operator*= (const complex& cmplx)

complex& complex: :operator/= (const complex& cmplx)

? Сложение, вычитание, умножение и деление cmplx и *this с сохранением результата в *this.

? Операторы возвращают *this.

? Операции определяются в обеих формах: как шаблонные и обычные функции. Тем самым обеспечивается автоматическое преобразование к типу элементов (это относится и к специализированным версиям из стандартной библиотеки С++). Обратите внимание: операторы присваивания -- единственные функции, позволяющие изменить значение существующего объекта complex.

Обращение к данным

Т complex:.real () const

Т real (const complex& cmplx)

T complex::imag () const

T imag (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()).

Операции ввода-вывода

ostream& operator« (ostream& strm, const complex& cmplx)

? Выводит значение cmplx в ноток данных strm в формате:

(вещественная_часть , мнимая_часть)

? Возвращает strm.

istream& operator» (istream& strm. complex& cmplx)

? Читает новое значение из потока данных strm в переменную cmplx.

? Допустимые форматы входных данных:

(вещественная_частъ , мнимая_часть)

(вещественная_часть)

вещественная __часть

? Возвращает strm.

Операторы

complex operator (const complex& cmplx)

Возвращает cmplx. complex operator (const complex& cmplx)

? Унарное изменение знака.

? Возвращает cmplx с обратными знаками вещественной и мнимой частей.

complex бинарна я_операция (const complex& cmplx1. const complex& cmplx2)

complex бинарная_операция (const complex& cmplx1. const T& value)

complex бинарная_операция (const T& value, const complex& cmplx2)

? Все формы возвращают комплексный результат выполнения заданной бинарной операции.

? Параметр бинарная_операция -- один из следующих операторов:

operator-operator* operator/

? Если при вызове оператора передается скалярное значение типа элемента, оно интерпретируется как вещественная часть, а мнимая часть инициализируется значением по умолчанию для своего типа (0 для базовых типов данных).

bool сравнение (const complex& cmplx1, const complex& cmplx2)

bool сравнение (const complex& cmplx1. const T& value)

bool сравнение (const T& value, const complex& cmplx1)

? Возвращает результат сравнения двух комплексных чисел или комплексного

числа со скалярным значением.

? Параметр сравнение -- один из следующих операторов:

operator == operator !=

? Если при вызове оператора передается скалярное значение типа элемента, оно интерпретируется как вещественная часть, а мнимая часть инициализируется значением по умолчанию для своего типа (0 для базовых типов данных).

? Обратите внимание: операторы <, <=, > и >= не поддерживаются.

Трансцендентные функции

complex pow (const complex& base, int exp)

complex pow (const complex& base, const T& exp)

complex pow (const complex& base, const complex& exp)

complex 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)

complex cos (const complex& cmplx)

complex tan (const complex& cmplx)

complex sinh (const complex& cmplx)

complex cosh (const complex& cmplx)

complex 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.2 Примеры использования класса complex

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

Листинг 3-Типовые операции класса complex

// num/complex1.cpp

#include <iostream>

#include <complex>

using namespace std;

int 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:

cout « "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;

cout « "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)

C2: (3.65844.3.40819)

c1: magnitude: 5 (squared magnitude: 25) phase angle: 0.643501

c2: magnitude: 5 (squared magnitude: 25) phase angle: 0.75

c1: conjugated: (4.-3)

c2: conjugated: (3.65844.-3.40819)

4.4 + c1 * 1.8: (11.6.5.4)

c1 + c2: (7.65844.6.40819)

c1 += sqrt(c1): (6.12132.3.70711)

Вторая программа в цикле читает два комплексных числа и вычисляет результат возведения первого числа в степень второго:

Листинг 4-цикл возведения первого числа во второе

// num/complex2.cpp

include <iostream>

#include <complex>

#include <cstdlib>

#include <limits>

using namespace std;

int main()

{

complex<long double> c1. c2;

while (cin.peek() != EOF)

{

// Ввод первого комплексного числа

cout « "complex number c1: ";

cin » c1;

if (!cin)

{

cout « "input error" « endl;

return EXIT_FAILURE;

// Ввод второго комплексного числа cout « "complex number c2: ";

cin » с2; if (!cin)

{

сout « "input error" « endl;

return EXIT_FAILURE:

)

if (c1 == c2)

{

cout « "c1 and c2 are equal !" « endl;

}

cout « "c1 raised to the c2: " « pow(c1.c2) « endl « endl;

// Пропуск оставшейся части строки

cin.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)

Обратите внимание: при вводе комплексного числа указывается либо только вещественная часть в виде отдельного значения (в круглых скобках или без), либо вещественная и мнимая части в круглых скобках, разделенные запятыми.

2.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);

std::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;

std::complex<double> cd;

std::complex<long_double> cld;

std::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;

std::complex<int> ci;

std::complex<double> cd4 = ci; // ОШИБКА: небезопасное преобразование std::complex<double> cd5(ci); // ОШИБКА: нет явного преобразования

std: :complex<double> cd6(ci.real () .ci .imag()); // OK

К сожалению, операторы присваивания позволяют выполнять небезопасные преобразования. Они определены в виде шаблонов для всех типов, поэтому присваивание допустимо для любых комплексных типов (при возможности пре-образования типа значения):

std: :complex<double> cd;

std: :complex<long double> cld;

std::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> не определено.

2.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.7 и с (c1.real0==1.7 && c1.imag()==0.0)
с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)

{

return std::abs(cl)<std;;abs(c2) ||

(std::abs(cl)==std::abs(c2) &&

std: :arg(cl)<std::arg(c2));

}

2.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>

std::basic_ostream<charT.traits>&

operator« (std: :basic_ostream<charT.traits>& strm. const std: :complex<T> c)

{

// Временная строка для выполнения вывода с одним аргументом

std: :basic_ostringstream<charT.traits> s:

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. Назначение программного обеспечения:

Разработанное программное обеспечение является калькулятором для комплексных чисел, в обязательные функции которого входит:

1. вычисление арифметических функций,

2. вычисление трансцедентных функций,

3. операция сравнения.

2. Описание реализации функций программы.

2.1 Вычисление всех заданных функций и вывод результата.

Для вычисления использовались стандартные функции библиотеки С++ Builder 6.0. Пример реализации операций описаны ниже:

Листинг 7 - Выполнение вычислений и вывод результата.

{

p=c1+c2; //Сложение чисел

c=FormatFloat("0.00",p.real());

d=FormatFloat("0.00",p.imag()); //Округление результата до сотых

Label7->Caption="("+c+"."+d+")"; //Вывод результата сложения

}

. . . . . . . . . . . . . . . . . . .

{

p=c1-c2; //Разность чисел

c=FormatFloat("0.00",p.real());

d=FormatFloat("0.00",p.imag());

Label7->Caption="("+c+"."+d+")";

}

. . . . . . . . . . . . . . . . . . . .

{

p=c1*c2; //Произведение чисел

c=FormatFloat("0.00",p.real());

d=FormatFloat("0.00",p.imag());

Label7->Caption="("+c+"."+d+")";

}

. . . . . . . . . . . . . . . . . . . .

{

if (c2.real()!=0.0 || c2.imag()!=0.0) //Если с2 не равно нулю то

{ //выполнить деление

p=c1/c2;

c=FormatFloat("0.00",p.real());

d=FormatFloat("0.00",p.imag());

Label7->Caption="("+c+"."+d+")";

}

else //иначе вывести ошибку

{ ShowMessage("Нельзя делить на ноль");

};

}

4.1 Вывод подсказки использования данной программы

Листинг 8 -Вывод окна помощи.

{

//Вывод сообщение с подсказкой

ShowMessage("Наберите два комплексных числа в данных полях (действительные и мнимые части каждого числа) и нажмите кнопку 'Ввести',изначально значения чисел заданы как нулевые. Далее выберите нужную операцию.");

}

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	файл пояснительной записки

Размещено на Allbest.ru