close

Вход

Забыли?

вход по аккаунту

?

kursova

код для вставкиСкачать
Московский Государственный Университет Приборостроения и Информатики
Курсовая Работа
По предмету :"Программирование и Основы алгоритмизации"
"Калькулятор" Група ИТ-8 ОтметкаБалловДата Басалаев А.М. Москва 2013
План выполнения задания
1.Провести аналитический обзор литературы по заданной теме.27.022.Разработать алгоритм и графическую схему программы решения задачи26.033.Написать программу на языках C / C + +.
Требования к программе:
1) программа должна работать в окне MSDOS под управлением операционной системы Windows
2) программа должна иметь интерфейс в виде окон и меню для выбора режимов ее работы, а также систему помощи;
3) предусмотреть ввода / вывода данных с клавиатуры и из файлов;
4) управление режимами работы программы выполнить с помощью
клавиатуры и мыши.23.044.Подготовить входные данные для контрольного примера.29.045.Реализовать и отладить программы на указанных языках программирования.6.Оформить записку к курсовой работе согласно требованиям Международных стандартов, соблюдая следующего содержания:
-введение;
-формулировка задачи;
-алгоритмы решения задачи;
-методы и средства решения задачи;
-описание программы на языке C / C + +;
-технология программирования, исполнения и отладки программы;
-инструкция пользователю;
-контрольный пример и анализ результатов компьютерной реализации программы;
-выводы;
-литература;
-приложения
Содержание:
Введение
1.Формулировка задачи .......................................................... 4
2. Методы и средства решения задачи ......................................... 6
3. Алгоритмы решения задачи ................................................ 11
4.Программа и её описание.......................................................18
4.1.Название программы ..................................................... .18
4.2. Назначение программы ..................................................18
4.3. Языки программирования, на которых написана программа ...18
4.4. Логическая структура программы .....................................18
4.5. Входные и выходные данные ......................................... ..19
4.6. Программные средства..................................................... 19
4.7. Технические средства ...................................................... 19
5. Технология программирования, исполнения и отладки программы 20
5.1. Технология программирования программы .........................20
5.2. Технология отладки программы..................................... ..20
5.3. Технология выполнения программы....................................20
6. Инструкция пользователю........................................................21
7. Контрольный пример и анализ результатов компьютерной реализации
программы...........................................................................26
Выводы
Список литературы
Приложение 1. Текст программы на языке Си
Приложение 2. Результаты работы программы
Введение
Целью курсовой работы является закрепление теоретических знаний и практических навыков программирования, полученных при изучении дисциплин "Основы программирования" и "Проблемно ориентированные языки программирования".
В ходе выполнения курсовой работы студенты должны научиться самостоятельно работать с литературой, разрабатывать алгоритмы, осуществлять их программную реализацию и от починки на современных компьютерных системах.
За последние годы произошел резкий скачок в развитии компьютерной техники и программного обеспечения с одновременным расширение сфер применения персональных компьютеров.
Программирование представляет собой комплекс по написанию системы программных кодов, которые будут осуществлять управление той или иной информационной системой, взаимодействие с которой осуществляется через информационные технологии.
Тема моей курсовой работы на сегодняшнее время является актуальной, так как настоящее время - это время цифровых технологий, где важное место занимает вычисления числовых данных, для простых инженерных вычислений практическим средством для этого является инженерный калькулятор, выполненный в виртуальном виде.
1.Формулювання задачи
В ходе данной курсовой работы я должен был сделать интерфейс программы, который бы обеспечивал диалог: Компьютера пользователь, для работы с числовыми вычислениями с помощью инженерного калькулятора. Интерфейс моей программы - это калькулятор в виртуальном исполнении, т.е. имеет такие кнопки, как цифры: 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 и функции: sin, cos, ln, lg, + / -, arccos, arcsin, sqrt, x ^ 2, x ^ y, n!, mod, div, действия: +, -, *, / другие = С, СЕ, BeakSpace, MC, MR, MS, M +.
В калькуляторе я предвосхитил основные математические законы, правила, такие как: деление на ноль, логарифм отрицательного числа, корень отрицательного числа, также пределы изменения синуса и косинуса для функций арксинус и арккосинус.
Также я предположил последовательное сложение чисел, вычитание, деление, умножение, последовательное стирание последней цифры, отсутствие двух ком.
Данная программа вычисляет данные, введенные с помощью нажатия мышкой соответствующих кнопок.
Данная программа может компилироваться в среде С + +, в том числе Borland C + + Builder. Сама программа реализована на языке С + +.
Также ее можно вызвать в операционной системе Windows и она будет работать в виде окна.
2. Методы и средства решения задачи
Ниже я приведу теоретические сведения, необходимые для решения данной задачи и помогут лучше понять специфику реализации задачи.
Операторы - это основные элементы, из которых строятся программы на любом языке программирования. Большинство операторов состоят из выражений. Выражение представляет собой объединение операций и операндов.
Самый выражение состоит из одного операнда.
Синтаксис оператора if:
if (<условие>)
<оператор1>;
[else <оператор2;>]
Оператор условия проверяет выражение приобретает истинного значения, если так, то выполняются операторы, расположенные непосредственно после условия, если выражение приобретает ложного значения, т.е. = 0, тогда выполняются следующие операторы. Оператор условия может использоваться для проверки более чем одной последовательной условия.
Синтаксис оператора выбора:
switch (<выражение целого типа>)
{
case <значение_1>:
< последовательность_операторов_1>;
break;
case <значение_2>:
< последовательность_операторов_2>;
break;
case <значення_n>:
< последовательность_операторов_n>;
break;
[default:
< последовательность_операторов _n +1>;]
}
Оператор-переключатель switch предназначен для выбора одного из нескольких альтернативных путей выполнения программы.
Оператор цикла for обеспечивает циклическое повторение определенного оператора определенное количество раз. Повторение цикла осуществляется с использованием переменной счетчика, изменяется при каждом прохождении тела программы.
Синтаксис оператора:
For (инициализация, проверка условия; новое значение)
В программировании массив - один из самых простых структур данных, совокупность элементов преимущественно одного типа данных, упорядоченных по индексам, которые обычно представлены натуральными числами, которые определяют положение элемента в массиве.
Массив может быть одномерным (вектором), и многомерным (например, двумерной таблице), то есть таким, где индексом является не одно число, а кортеж (совокупность) из нескольких чисел, количество которых совпадает с размерностью массива
В большинстве языков программирования массив является стандартной встроенной структурой данных.
В программировании и компьютерных науках структуры данных - это способы организации данных в компьютерах. Часто вместе со структурой данных связывается и специфический перечень операций, которые могут быть выполнены над данными, организованными в такую ​​структуру.
Правильный подбор структур данных является чрезвычайно важным для эффективного функционирования соответствующих алгоритмов их обработки. Хорошо построенные структуры данных позволяют оптимизировать использование машинного времени и памяти компьютера для выполнения наиболее критичных операций.
Указатель (указатель) - это переменная или константа стандартного типа данных для хранения адреса переменной определенного типа. Значение указателя - это беззнаковое целое, оно сообщает, где находится переменная, и ничего не говорит о самой переменной.
Переменная типа указатель объявляется подобно обычным переменным с применением унарные символа "*". Форма объявления переменной типа указатель следующая:
тип [модификатор] * имени-указателя;
Для определения длины строки используется функция strlen (). Ее синтаксис:
size_t strlen (const char * s);
Функция strlen () возвращает длину строки s, при этом завершающий нулевой символ не учитывается.
Структуры позволяют объединять в едином объекте совокупность значений, которые могут иметь различные типы. Объявления структуры осуществляется с помощью ключевого слова struct.
Синтаксис описания структуры выглядит так:
struct [имя_структуры]
{
тип1 елемент1;
тип2 елемент2;
типN елементN;
} [Список описаний];
Операция решения видимости :: (scope resolution operator) позволяет осуществить доступ к глобальной переменной или функции из блока, в котором объявлена ​​локальная переменная с тем же именем. Например, выражение :: I означает глобальную переменную И даже если в данном блоке объявлена ​​локальная переменная с таким же именем И.
Для управления распределением динамической памяти в C + + широко используются операторы new и delete. Они заменяют известные нам из языка Си malloc, calloc, free, однако это не означает, что все они не могут использоваться в Си + +. Все дело именно в гибкости новых операторов: new возвращает указатель на тип, для которого выделяется память, в то время как malloc возвращает пустой указатель, поэтому в первом случае отпадает необходимость использовать преобразование типа.
КЛАСС (class) - это определенный пользователем тип данных, применяемый для описания абстрактной множества объектов, которые пов.язани обобщением структуры и поведения. В синтаксическом смысле класс в C + + очень напоминает определение структуры в Си, исключая некоторых моментов. Во-первых, он может включать в себя одну или несколько спецификаций доступа задаются как public, private или protected, во-вторых, класс, как правило, может включать в себя еще и функции-методы наряду с элементами-данными.
Синтаксис:
class <имя> {
[Private:]
[<Описание скрытых элементов>]
[Protected:
<Описание защищенных элементов>]
[Public:
<Описание доступных элементов>]
};
К элементам класса (структуры) можно обращаться двумя способами - это первое, если объявлено через массив, тогда в таком виде: [имя класса]. [Название элемента класса] или если класс объявлен через указатель, тогда объявление будет выглядеть так: [ имя класса] -> [название элемента].
В языке С + + есть три вида спецификаторов доступа это: public; protected; private.
Public - это элементы и и элементы Данные доступны для функций-элементов и других функций, где имеет место представитель класса
Private - элементы Данные и элементы-функции доступны только для функций-элементов текущего класса
Protected - элементы Данные и элементы-функции доступны только для функций-элементов текущего класса и классов, производных от него.
Функции - это отдельная подпрограмма, которая решения связывает определенную подзадачу, она имеет свой тип, свои формальные переменные. Функция облегчает решение Обязательства основной задачи, делит программу на логические подструктуры.
Функция объявляется так:
Тип результата
название функции (список формальных параметров)
спецификации параметров
{
Тело функции
}
Название функции выбирается программистом, она не должна совпадать с названием переменных, служебных слов и библиотечных функций.
Функция всегда должна возвращать результат в точку вызова с помощью служебного слова return.
В своей работе я также использовал следующие функции: функции перевода символьных данных в числовые - это StrToFloat (переменная), функция перевода числовых данных в символьные FloatToStr (переменная), Edit1-> Text.Length () - для определения длины строки редактирования Edit1- > Text.operator [] (1) - обращение к первому элементу строки Edit, Edit1-> Text.Delete () - стирание элемента строки Edit, Edit1-> Text.Insert () - вставки в строку Edit символа, pow (x, y) - возведения числа x в степень y. Чтобы не допустить нарушения таких законов математики как деление на ноль и других, я ввел переменную, если она равна символа 'e', ​​то выводится сообщение об ошибке. Проверка этой переменной происходит при каждом действии. Также нужно было ввести переменные, отвечающие за наличие слагаемых, переменную, приобретает значение true при нажатии кнопки = также ввел переменные, отвечающие за наличие чего-то в памяти и переменную, отвечает за наличие комы. Для того, чтобы сделать ввод суммирования, умножения чисел непрерывным, без нажатия кнопки равно, я ввел переменную, в которой содержится последнее введенное число.
Теперь я приведу методы, с помощью которых функционируют некоторые кнопки:
BeakSpace
В этой кнопке я предусмотрел следующие ситуации: когда в поле введена одна цифра или когда введено однозначное отрицательное число, то при нажатии кнопки в поле снова содержатся символы '0, ', также когда содержится в поле отрицательное число с одной цифрой после комы, поле очищается и снова содержит '0, '. При целом положительном и с точкой стирается последняя цифра числа. Когда число не является целым числом, то при стирании последней цифры после запятой переменная point приобретает значение false.
Для этого я использовал такие операторы: Edit1-> Text.Length (), Edit1-> Text.operator [] Edit1-> Text.Delete.
Для кнопки изменения знака нужно было предусмотреть два случая - это когда число отрицательное и когда положительное. Когда число отрицательное, то стирается первый знак "-" с помощью оператора Edit1-> Text.operator []. Когда число положительное, то вставляется знак "-" с помощью оператора Edit1-> Text.Insert ().
При нажатии кнопки "," переменная point приобретает значение true. При нажатии кнопки '=' переменная end приобретает значение true.
Корень квадратный
Первое нужно проверить условие или число положительное, если так то вычисляется результат так: pow (StrToFloat (Edit1-> Text), 0.5), если число отрицательное, то вывести соответствующее сообщение.
Квадрат
Для квадрата нужно использовать такую ​​функцию: pow (StrToFloat (Edit1-> Text), 2).
Факториал
Чтобы вычислить факториал нужно ввести переменную-счетчик, которая при каждом цикле изменяется на 1 и так пока не будет равным числу, факториал которого считаешь.
Для действий с одним числом такими как корень квадратный, синус, косинус, арксинус, арккосинус, логарифм нужно, чтобы логические переменные, отвечающие за наличие слагаемых, содержания в строке Edit изменили свое значение на противоположное.
Также нужно изменить переменную, отвечающую за действие, например в знак '\ 0'.
Такое действие необходимо выполнить после каждой операции.
3. Алгоритмы решения задачи
long double Action(long double c)
void Calculate(TEdit *Edit1, cCalc *Tc, char cd)
void Numbers(TEdit *Edit1, cCalc *Tc, char num)
BackSpace
Кнопка +/-
Кнопка =
Корень квадратный
Квадрат
Ln(x)
4.Программа и ее описание
4.1.Название программы.
Программа "Инженерный калькулятор";
4.2.Призначення программы.
Программа предназначена для выполнения несложных арифметических и алгебраических вычислений. Также вычислений таких тригонометрических функций, как синус, косинус, арккосинус, арксинус. Программа выполняет следующие функции: сложение, вычитание, умножение, деление, возведение в степень, корень квадратный, натуральный логарифм, десятичный логарифм, факториал, изменение знака. Программа может использоваться как вспомогательное средство при исчислении числовых данных.
4.3.Языки программирования, на которых написана программа.
Программа написана на языке Си.
Язык Си является языком среднего уровня. Язык Си имеет средства системного программирования включает в себя все конструкции современных алгоритмических языков, лучше учитывает возможности современных компьютерных систем, а также мобильной языке. Она несколько отличается от Си, а именно новыми служебными словами, наличием классов и некоторыми другими функциями.
4.4. Логическая структура программы.
Программа состоит из следующих логических частей, если учитывать особенности программирования в среде C + + Builder, как My_kursova.bpr, My_kursova.exe, основной файл, где содержится код программы My_kursova.cpp.
Данная программа имеет следующую структуру:
Функции файла My_kursova.cpp
Action (long double c) - это функция, которая в зависимости от действия, которое нужно выполнить и наличия слагаемых производит вычисления.
void Calculate (TEdit * Edit1, cCalc * Tc, char cd) - это функция, в зависимости от нажатой кнопки вычисляет результат.
void Numbers (TEdit * Edit1, cCalc * Tc, char num) - это функция, которая вводит в строку редактирования цифры.
Формальным параметром функции Action является с, равное числу, которое вводится и над которым нужно выполнить вычисления.
Формальными параметрами функции Calculate есть строка редактирования, то есть его содержание, класс cCalc, содержащий логические переменные, и cd - действие, которое нужно выполнить.
Формальными параметрами функции Numbers есть строка редактирования, то есть его содержание, класс cCalc, содержащий логические переменные, и num - число, вводится.
Учитывая особенности программирования в среде C + + Builder, код программы содержит код, каждой отдельно запрограммированной кнопки, но существует на диске как единое целое.
My_kursova.bpr - это проект создан средой.
My_kursova.exe - это файл, запускающий файл на исполнение.
Все функции в данной программе являются взаимосвязанные. Обмен информацией между ними происходит как через локальные, так и через глобальные переменные, а также через список фактических-формальных параметров.
4.5. Входные и выходные данные.
Входными данными в данной программе являются числовые данные и действие или операция, которую нужно выполнить над ними. Исходными данными в данной программе является результат выполнения вычислений.
4.6. Программные средства.
Желательно иметь среду Borland_C + _Builder.А также установленную операционную систему Windows. На других ОС данная программа не тестировалась.
Программа должна работать в виде окна-калькулятора под управлением Windows.
Но запускаться с помощью файла Project1.exe или среды.
Для работы программы необходима ОС: Windows 95/98/ME, Windows 2000; Windows XP; Windows Vista,Windows 7;
Для компиляции проекта необходим компилятор Borland_C + _Builder, библиотечные функции: math.h, vcl.h.
4.7. Технические средства.
Программа не требует особой конфигурации компьютера, поэтому будет работать практически на всех конфигурациях.
5. Технология программирования, исполнения и отладки программы
5.1. Технология программирования программы.
Использование модели в разработке и решении сложных задач является одним из важнейших методов. Модель - это заменитель объекта исследования, находится с ним в таком соответствии, которая позволяет получить новое значение об объекте.
Поскольку модель основывается на аналогии, то она теряет смысл средства познания как в случае тождества модели и объекта исследования, так и в случае очень больших различий между ними. Таким образом моделирование связано с упрощением, абстрагированием прототипа от ряда его свойств, признаков, сторон. Однако чрезмерно упрощенная модель может привести к несоответствию с исследуемым объектом, сделает невозможным исследование его с помощью такой модели. С другой стороны, учет в модели как можно большего количества свойств исследуемого объекта приводит к усложнению процесса исследования.
Для решения своей задачи я использовал средства объектно-ориентированного языка программирования C + +. Каждый стиль программирования имеет свою концептуальную основу, требует разного подхода к решению задачи. Для объектно-ориентированного стиля концептуальная основа заключается в объектном подходе. Этому подходу соответствуют четыре главных элемента: абстрагирование, ограничение доступа, модульность и иерархия.
1. Абстрагирование - выделение таких весомых характеристик
объектов, которые отличают его от всех других объектов и которые
четко определяют особенности данного объекта с точки зрения
дальнейшего анализа.
2. Ограничение доступа - процесс защиты отдельных элементов,
который не влияет на весомые характеристики объекта как целого.
3. Модульность - свойство системы, которая связана с
возможностью декомпозиции на ряд тесно связанных модулей
(Частей).
4. Иерархия - порядок по некоторым правилам объектов
системы.
Идея классов - это основа объектно-ориентированного программирования (ООП). Цель ООП - попытка связать данные и функции для их обработки в единое целое - класс. В классах объединяются структуры данных и функции их обработки. Идея классов отражает строение объектов реального мира - поскольку каждый предмет или процесс имеет свои свойства, строение, поведение.
Класс - это определяемый пользователем тип данных. В классе задаются свойства и поведение какого-либо, объекта в виде полей-данных и функций для работы с ними.
Парадигма программирования - это набор теорий, методов, стандартов, используемых при разработке и реализации программ на компьютере. ООП часто называют новой парадигмой программирования, хотя ее революционный прогресс начался давно в прошлом. ООП основано на трех принципах, которые предоставляют классам новые свойства:
1. Инкапсуляция - объединение в единое целое данных и алгоритмов обработки этих данных. В ООП данные называются полями, а алгоритмы - методами или функциями-членами (methods, member functions).
2. Наследование - свойство создания иерархии классов, когда потомки получают от предшественника поля и методы.
3. Полиморфизм (от гр. Poly - много и morphos форма, значит много форм) - это свойство классов одной иерархии решать схожие по смыслу задачи с помощью различных алгоритмов.
Абстрагирование - одно из главных средств, используемых для решения сложных задач.
Абстракция - это достаточно существенные характеристики некоторого объекта, которые отличают его от всех других видов объектов и, таким образом, четко определяют особенности данного объекта с точки зрения дальнейшего рассмотрения и анализа.
Абстрагирование концентрирует внимание на внешних особенностях объекта и дозвjляе отделить наиболее существенные особенности поведения от деталей их осуществления. Такое распределение можно назвать барьером абстракции, который основывается на принципе минимизации связей, когда интерфейс объекта содержит только существенные аспекты поведения. Полезно еще один вспомогательный принцип, называемый принципом наименьшей выраженности, по которому абстракция должна охватывать только самую суть объекта, не более, но и не меньше. Выбор достаточного множества абстракций для заданной предметной области является главной проблемой объектно-ориентированного проектирования. Существует целый спектр абстракций, который начинается с объектов, примерно соответствуют сущности предметной области, и заканчивается объекты, не имеют реальных аналогов в жизни. Повысить степень абстракции можно:
1. описанием собственных типов данных;
2. использованием функций;
3. объединение типов данных и функций в модуле;
4. использованием классов.
Наиболее интересны для нас абстракции сущности объектов, так как они соответствуют словаре предметной области. Описание поведения объекта содержит описание операций, которые могут выполняться над ним, и операций, которые сам объект выполняет над другими объектами. Такой подход концентрирует внимание на внешних особенностях объекта. Созданию абстракции любого объекта должны предшествовать определенные решения о средстве реализации. Выбранный способ реализации должен быть скрыт и защищен для большинства объектов-пользователей (которые обращаются к данной абстракции). Понятие ограничения доступа можно определить следующим образом:
Ограничение доступа - это процесс защиты отдельных элементов объекта, не нарушает существенных характеристик объекта как целого.
Абстрагирование и ограничения доступа являются взаимодополняющими факторами: абстрагирование фокусирует внимание на внешних особенностях объекта, а ограничение доступа - или иначе защита информации - не позволяет объектам-пользователям различать внутреннее строение объекта.
На практике осуществляется защита как структуры объекта, так и реализации его методов. В языке C + + управление доступом и видимостью достигается с большой гибкостью. Элементы объекта могут быть отнесены к общедоступной, отделенной или защищенной части. Модульность - это свойство программной системы, которая связана с возможностью декомпозиции ее на ряд внутренне связанных на слабо связанных между собой модулей.
Распределение программы на отрывки (части) позволяет частично уменьшить ее сложность, однако гораздо важнее тот факт, что этот процесс улучшает обработки ее частей. Эти части очень ценны для исчерпывающего понимания программы в целом. Модульность является элементом конструкции в Си и позволяет осуществлять на ее основе проектные решения.
В языке C + + классы и объекты составляют логическую структуру системы; как абстракции организуются в модуле, которые образуют физическую структуру системы. Такое свойство становится особенно полезной, когда система состоит из многих десятков, а то и сотен классов.
5.2. Технология выполнения программы.
Выполнение программы выполняется частями. Сначала создаются подпрограммы, которые облегчают программирование требуемой задачи, и которые будут использоваться в тексте основной программы. В нашем случае такими подпрограммами являются:
Функция для ввода цифр в поле редактирования - Numbers;
Функция, производит вычисления в зависимости от действия, которое нужно выполнить и наличия слагаемых делает вычисления - Action;
Calculate - это функция, в зависимости от нажатой кнопки вычисляет результат.
Также можно рассмотреть программный код каждой кнопки как отдельную подпрограмму, поэтому получим подпрограммы для вычисления следующих функций:
• Синус
• Косинус
• Натуральный логарифм
• Факториал
• Корень квадратный
• Квадрат
• Возведение в произвольного степени числа
• Арксинус
• арккосинус
• Целочисленное деление
• Остаток от деления
• Деление
• Умножение
• Добавление
• Вычитание
5.3. Технология отладки программы.
Для того, чтобы отладить программу, нужно использовать пошаговое подключение подпрограмм (так мы быстрее поймем в какой части программы есть ошибки и последовательно исправим эти ошибки). То есть сначала мы записываем подпрограммы в основной текст программы, затем, при наличии ошибок, мы меняем пидпрогамы к такому виду, который требует этот текст и синтаксис языка Си. Затем подстраиваем их под текст программы и проверяем их рабочую эффективность. Пытаются сделать наилучшую эффективность путем изменения текста подпрограмм.
После успешного подключения главных подпрограмм подсоединяются другие подпрограммы (таким образом, как и основные подпрограммы). Пытаются создать лучшую взаимодействие путем перестановки или изменения текста подпрограмм.
6. Инструкция пользователю
Интерфейс программы реализован в графическом режиме. Интерфейс является удобным в использовании и не требует значительных ресурсов компьютера для работы в нем.
Управление программой осуществляется полностью с помощью мышки.
Есть два способа по запуску программы на выполнение:
1) Запуск через среду программирования
Этот способ удобен тем, что при наличии желаний пользователя что-то изменить в программе можно сразу же выйти из программы в среду программирования и изменить определенный код, при этом сразу же откомпилировать вновь код.
Определенной неудобством является то, что не все могут иметь самое среду программирования или компилятор. Для запуска программы нужно иметь не менее среда Borland C + + Builder 6. На предыдущих версиях приложение не тестировалась.
Чтобы запустить программу на выполнение из среды программирования нужно нажать клавиши F9. Или осуществить следующие действия в меню самой среды: Run -> Run.
2) Запуск через операционную систему
На мой взгляд, этот способ гораздо удобнее предыдущего. Чтобы запустить программу через операционную систему нужно найти файл My_kursova.exe и два раза кликнуть по нему мышкой. В результате программа будет запущена в окне под управлением операционной системы.
Недостатком этого способа является то, что изменения в программный код программы вносить нельзя.
Когда программа запустилась появляется окно выглядит так:
Сверху находится строка, где отображаются введенные данные и результаты расчета. В верхнем правом углу есть кнопки для переключения между градусами и радианами, соответственно, если нужно вычислить синус или косинус от величины указанной в градусах, нужно, чтобы отмеченной была кнопка "градуса", в противном случае отмеченной должна быть кнопка "радианы".
Ниже находятся следующие кнопки: BeakSpace, C, CE. BeakSpace для стирания последней цифры числа. C для очистки поля ввода / вывода. CE для удаления числа, отображается в поле вычисления.
Далее расположены следующие кнопки: цифры от 0 до 9, изменение знака + / -, кома "," равна, действия Добавление +, вычитание -, умножение * Деление /, кнопки работы с памятью MR для вызова числа из памяти 'памяти, MS для занесения числа в память, MC для очистки памяти, M + для добавления произвольного числа в число в памяти, mod - остаток от деления, div - целочисленное деление, sin - синус, cos - косинус, ln - натуральный логарифм, lg - десятичный логарифм, n! - Факториал, sqrt - корень квадратный, x ^ 2 - квадрат, x ^ y - возвышение к произвольному степени числа, arcsin - арксинус, arccos - арккосинус.
7.Контрольный пример и анализ результатов компьютерной реализации программы
Для программы "инженерный калькулятор" входными данными являются числовые данные, поэтому в качестве примера и анализа результатов, я использовал набор различных чисел в которых применил различные функции.
Последовательность выполнения:
1. 23 +24 +12-33 = 26
2. 44 * 55 * 77 = 186 340
3. 33 '+ / -' - 22 = -55
4. 44443 'beakspace' = 4444
5. 25 mod 2 = 1
6. 25 div 2 = 12
7. 64 'sqrt' = 8
8. 4 'x ^ y' 2 = 16
9. 5 'n!' = 120
10. 30 'sin (x)' = 0,5
Все вычисления выполнены на калькуляторе, результаты имеют вид:
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
При изменении входных данных результат правильный. Никаких сбоев программы не отмечено.
Выводы
После выполнения своей курсовой работы я приобрел практические навыки работы в среде объектно-ориентированного программирования. Научился программировать в среде Builder C + + и работать с объектами, создавать форму, программировать кнопки, работать со строкой редактирования Edit, осуществлять доступ к элементам строки Edit, выполнять операции над ними, также научился объявлять классы, работать с элементами класса, закрепил навыки работы с циклами и создания функций.
Полученная программа является качественной, быстрой при исполнении и не требует значительных ресурсов компьютера для ее запуска.
Данная программа может пригодиться для очень многих пользователей, предприятий, учебных заведений. Она является универсальной, поскольку калькулятор является неотъемлемым атрибутом любой компьютерной системы. Поэтому актуальность данной программы чрезвычайно велика.
Приложение 1. Текст программы на языке C + +
//---------------------------------------------------------------------------
#include <math.h>
#include <vcl.h>
#pragma hdrstop
#include "Unit1.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
class cCalc
{
public:
long double a,b,last,memory;
bool a1,b1,end,flag,point, mem;
char d; cCalc()
{
a1=b1=point=end=flag=memory=false;
}
long double Action(long double c)
{
if (a1==false && b1==false)
{
a1=true;
a=c;
return a;
}
else if (a1 && b1==false)
{
switch (d)
{
case '+': {
b=c;
a=a+b;
last=b;
b=0;
return a;
}
case '-': {
b=c;
a=a-b;
last=b;
b=0;
return a;
}
case '*': {
b=c;
a=a*b;
last=b;
b=0;
return a;
}
case '/': {
b=c;
if (b!=0)
{
a=a/b;
last=b;
b=0;
return a;
}
else d='e';
}
case '%': {
b=c;
if (b!=0)
{
b=c;
a=(int)a % (int)b;
last=b;
b=0;
return a;
}
else d='e';
}
case 'd': {
b=c;
if (b!=0)
{
b=c;
a=(int)a / (int)b;
last=b;
b=0;
return a;
}
else d='e';
}
case '^': {
b=c;
a=pow(a,b);
last=a;
b=0;
return a;
}
}
}
else if (a1 && b1)
{
switch (d)
{
case '+': return a=a+last;
case '-': return a=a-last;
case '*': return a=a*last;
case '/': {
if (last!=0)
{
a=a / last;
return a;
}
else d='e';
}
case '%': {
if (last!=0)
{
a=(int)a % (int)last;
return a;
}
else d='e';
}
case 'd': {
if (last!=0)
{
a=(int)a / (int)last;
return a;
}
else d='e';
}
case '^': return a*=last;
};
}
}
};
void Calculate(TEdit *Edit1, cCalc *Tc, char cd)
{
if (Tc->d=='e') Edit1->Text="Error!";
else
{
if (!Tc->end)
{
if (Tc->d==cd || Tc->d=='\0')
{
Tc->d=cd;
if (Tc->a1 && !Tc->b1 && !Tc->flag)
{
Edit1->Text=FloatToStr(Tc->Action(StrToFloat(Edit1->Text)));
Tc->flag=true;
}
else if (!Tc->a1 && !Tc->b1)
{
Edit1->Text=FloatToStr(Tc->Action(StrToFloat(Edit1->Text)));
Tc->flag=true;
}
}
else
{
if (!Tc->flag)
{
Edit1->Text=FloatToStr(Tc->Action(StrToFloat(Edit1->Text)));
Tc->a1=Tc->flag=true;
Tc->b1=false;
Tc->a=StrToFloat(Edit1->Text);
}
Tc->d=cd;
}
}
else if (!Tc->flag)
{
Tc->d=cd;
Tc->b1=Tc->end=false;
Tc->a1=Tc->flag=true;
Tc->a=StrToFloat(Edit1->Text);
}
}
}
void Numbers(TEdit *Edit1, cCalc *Tc, char num)
{
if (Tc->d=='e') Edit1->Text="Error!";
else
{
if (Tc->flag || (Tc->point==false && Edit1->Text=="0,"))
{
Edit1->Clear();
Tc->flag=false;
Tc->point=false;
}
Edit1->Text=Edit1->Text+num;
}
}
TForm1 *Form1;
cCalc *Tc= new cCalc;
__fastcall TForm1::TForm1(TComponent* Owner)
: TForm(Owner)
{
}
//============================================================
//======================' + '====================================
void __fastcall TForm1::Button13Click(TObject *Sender)
{
Calculate(Edit1, Tc,'+');
}
//======================' - '====================================
void __fastcall TForm1::Button14Click(TObject *Sender)
{
Calculate(Edit1, Tc,'-');
}
//======================' * '====================================
void __fastcall TForm1::Button15Click(TObject *Sender)
{
Calculate(Edit1, Tc,'*');
}
//======================' / '====================================
void __fastcall TForm1::Button16Click(TObject *Sender)
{
Calculate(Edit1, Tc,'/');
}
//======================' Mod '==================================
void __fastcall TForm1::Button25Click(TObject *Sender)
{
Calculate(Edit1, Tc,'%');
}
//======================' Div '==================================
void __fastcall TForm1::Button26Click(TObject *Sender)
{
Calculate(Edit1, Tc,'d');
}
//======================' x^y '==================================
void __fastcall TForm1::Button29Click(TObject *Sender)
{
Calculate(Edit1, Tc,'^');
}
//===============================================================
//==========================================================
//========================' 1 '==================================
void __fastcall TForm1::Button2Click(TObject *Sender)
{
Numbers(Edit1, Tc, '1');
}
//========================' 2 '==================================
void __fastcall TForm1::Button3Click(TObject *Sender)
{
Numbers(Edit1, Tc, '2');
}
//========================' 3 '==================================
void __fastcall TForm1::Button4Click(TObject *Sender)
{
Numbers(Edit1, Tc, '3');
}
//========================' 4 '==================================
void __fastcall TForm1::Button5Click(TObject *Sender)
{
Numbers(Edit1, Tc, '4');
}
//========================' 5 '==================================
void __fastcall TForm1::Button6Click(TObject *Sender)
{
Numbers(Edit1, Tc, '5');
}
//========================' 6 '==================================
void __fastcall TForm1::Button7Click(TObject *Sender)
{
Numbers(Edit1, Tc, '6');
}
//========================' 7 '==================================
void __fastcall TForm1::Button8Click(TObject *Sender)
{
Numbers(Edit1, Tc, '7');
}
//========================' 8 '==================================
void __fastcall TForm1::Button9Click(TObject *Sender)
{
Numbers(Edit1, Tc, '8');
}
//========================' 9 '==================================
void __fastcall TForm1::Button10Click(TObject *Sender)
{
Numbers(Edit1, Tc, '9');
}
//========================' 0 '==================================
void __fastcall TForm1::Button1Click(TObject *Sender)
{
if (Tc->point) Numbers(Edit1, Tc, '0');
else if (StrToFloat(Edit1->Text)>0) Numbers(Edit1, Tc, '0');
}
//===============================================================
//========================BeakSpace==============================
void __fastcall TForm1::Button18Click(TObject *Sender)
{
if (Tc->d=='e') Edit1->Text="Error!";
else
{
if (Edit1->Text.Length()==1 ||
(Edit1->Text.Length()==2 && Edit1->Text.operator [](1)=='-'))
{
Edit1->Text="0,";
Tc->point=false;
}
else
if (Edit1->Text.Length()==4 && Edit1->Text.operator [](1)=='-' &&
Edit1->Text.operator [](2)=='0' && Edit1->Text.operator [](3)==',')
{
Edit1->Text="0,";
Tc->point=false;
}
else
if (Edit1->Text.operator [](Edit1->Text.Length())==',' &&
Edit1->Text!="0,")
{
Tc->point=false;
Edit1->Text=Edit1->Text.Delete(Edit1->Text.Length(),1);
}
else
if (Edit1->Text!="0,") Edit1->Text=Edit1->Text.Delete(Edit1->Text.Length(),1);
}
}
//===============================================================
//========================' +/- '================================
void __fastcall TForm1::Button11Click(TObject *Sender)
{
if (Tc->d=='e') Edit1->Text="Error!";
else
{
if (Edit1->Text.operator [](1)=='-')
Edit1->Text=Edit1->Text.Delete(1,1);
else if (Edit1->Text!="0,") Edit1->Text=Edit1->Text.Insert("-",1);
}
}
//===============================================================
//========================' , '==================================
void __fastcall TForm1::Button12Click(TObject *Sender)
{
if (Tc->d=='e') Edit1->Text="Error!";
else
{
if (Edit1->Text!="0," && Tc->point==false)
Edit1->Text=Edit1->Text+',';
Tc->point=true;
}
}
//===============================================================
//========================' = '==================================
void __fastcall TForm1::Button17Click(TObject *Sender)
{
if (Tc->d=='e') Edit1->Text="Error!";
else
{
if (Tc->a1)
{
Edit1->Text=FloatToStr(Tc->Action(StrToFloat(Edit1->Text)));
if (Tc->d=='e') Edit1->Text="Error!";
if (!Tc->b1) Tc->b1=true;
Tc->end=true;
}
}
}
//===============================================================
//========================================
void __fastcall TForm1::FormCreate(TObject *Sender)
{
Tc->point=false;
}
//===============================================================
//==============='корень квадратный '==========================
void __fastcall TForm1::Button27Click(TObject *Sender)
{
if (Tc->d=='e') Edit1->Text="Error!";
else
{
if (StrToFloat(Edit1->Text)>=0)
{
Edit1->Text=FloatToStr(pow(StrToFloat(Edit1->Text),0.5));
Tc->flag=true;
Tc->a1=false;
Tc->b1=false;
Tc->d='\0';
}
else
{
Edit1->Text="Error!";
Tc->d='e';
}
}
}
//===============================================================
//====================='квадрат'===============================
void __fastcall TForm1::Button28Click(TObject *Sender)
{
if (Tc->d=='e') Edit1->Text="Error!";
else
{
Edit1->Text=FloatToStr(pow(StrToFloat(Edit1->Text),2));
Tc->flag=true;
Tc->a1=false;
Tc->b1=false;
Tc->d='\0';
}
}
//===============================================================
//===================='факториал'==============================
void __fastcall TForm1::Button30Click(TObject *Sender)
{
if (Tc->d=='e') Edit1->Text="Error!";
else
{
if (StrToFloat(Edit1->Text)>=0)
{
long double fact;
fact=1.0;
for (int i=1; i<(int)StrToFloat(Edit1->Text)+1; i++)
fact*=i;
Edit1->Text=FloatToStr(fact);
Tc->flag=true;
Tc->a1=false;
Tc->b1=false;
Tc->d='\0';
}
else
{
Edit1->Text="Error!";
Tc->d='e';
}
}
}
//===============================================================
//======================' Ln(x) '================================
void __fastcall TForm1::Button31Click(TObject *Sender)
{
if (Tc->d=='e') Edit1->Text="Error!";
else
{
if (StrToFloat(Edit1->Text)>0)
{
Edit1->Text=log(StrToFloat(Edit1->Text));
Tc->flag=true;
Tc->a1=false;
Tc->b1=false;
Tc->d='\0';
}
else
{
Edit1->Text="Error!";
Tc->d='e';
}
}
}
//===============================================================
//======================' Lg(x) '================================
void __fastcall TForm1::Button32Click(TObject *Sender)
{
if (Tc->d=='e') Edit1->Text="Error!";
else
{
if (StrToFloat(Edit1->Text)>0)
{
Edit1->Text=FloatToStr(log10(StrToFloat(Edit1->Text)));
Tc->flag=true;
Tc->a1=false;
Tc->b1=false;
Tc->d='\0';
}
else
{
Edit1->Text="Error!";
Tc->d='e';
}
}
}
//===============================================================
//======================' Sin(x) '===============================
void __fastcall TForm1::Button33Click(TObject *Sender)
{
if (Tc->d=='e') Edit1->Text="Error!";
else
{
float p;
if (RadioButton1->Checked) p=StrToFloat(Edit1->Text)*M_PI/180;
else p=StrToFloat(Edit1->Text);
Edit1->Text=FloatToStr(sin(p));
}
}
//======================' Cos(x) '===============================
void __fastcall TForm1::Button34Click(TObject *Sender)
{
if (Tc->d=='e') Edit1->Text="Error!";
else
{
float p;
if (RadioButton1->Checked) p=StrToFloat(Edit1->Text)*M_PI/180;
else p=StrToFloat(Edit1->Text);
Edit1->Text=FloatToStr(cos(p));
}
}
//===============================================================
//===================' ArcSin(x) '===============================
void __fastcall TForm1::Button35Click(TObject *Sender)
{
if (Tc->d=='e') Edit1->Text="Error!";
else
{
if (abs(StrToFloat(Edit1->Text))>1) Tc->d='e';
else
if (RadioButton1->Checked)
Edit1->Text=asin(StrToFloat(Edit1->Text))/M_PI*180;
else
Edit1->Text=asin(StrToFloat(Edit1->Text));
}
}
//===============================================================
//===================' ArcCos(x) '===============================
void __fastcall TForm1::Button36Click(TObject *Sender)
{
if (Tc->d=='e') Edit1->Text="Error!";
else
{
if (abs(StrToFloat(Edit1->Text))>1) Tc->d='e';
else
if (RadioButton1->Checked)
Edit1->Text=acos(StrToFloat(Edit1->Text))/M_PI*180;
else
Edit1->Text=acos(StrToFloat(Edit1->Text));
}
}
//===============================================================
//========================' MS '=================================
void __fastcall TForm1::Button21Click(TObject *Sender)
{
Tc->memory=StrToFloat(Edit1->Text);
Tc->mem=true;
}
//===============================================================
//========================' MR '=================================
void __fastcall TForm1::Button22Click(TObject *Sender)
{
if (Tc->mem) Edit1->Text=FloatToStr(Tc->memory);
}
//===============================================================
//========================' MC '=================================
void __fastcall TForm1::Button23Click(TObject *Sender)
{
Tc->mem=false;
}
//===============================================================
//========================' M+ '=================================
void __fastcall TForm1::Button24Click(TObject *Sender)
{
Tc->memory+=StrToFloat(Edit1->Text);
}
//===============================================================
//==========================' CE '===============================
void __fastcall TForm1::Button19Click(TObject *Sender)
{
Tc->a1=Tc->b1=Tc->point=Tc->end=Tc->flag=Tc->memory=false;
Tc->d='\0';
Edit1->Text="0,";
}
//===============================================================
//=========================' C '==================================
void __fastcall TForm1::Button20Click(TObject *Sender)
{
if (Tc->d!='e') Edit1->Text="0,";
}
//===============================================================
ЛИТЕРАТУРА
1) Кравец П. А. Методические указания к выполнению лабораторных работ по дисциплине "Проблемно-ориентированные языки программирования", 2005.
2) Кравец П. А. Методические указания к выполнению курсовой работы по дисциплине "Проблемно-ориентированные языки программирования", 2005
3) Культин Н. С, С + + в задачах и примерах, Санкт-Петербург 2005.
4) Ричард Хезфилд, Лоуренс Кирби Исскуство программирования на С, Москва, Санкт-Петербург 2001
5) Павловская Т. А., Щупак Ю. А. С, С + + - программирование на языке высокого уровня (Структурное программирование), Санкт-Петербург 2003
6) Романов Е. Л. Практикум по программированию на С + +, Санкт-Петербург 2004
7) В.В. Войтенко С / С + + теория и практика, учебно-методическое пособие.
8) Программирование в С + + Builder 6 и 2006 (Архангельский А.Я., тагином М.А., 2007)
9) Стивен Прата, Язык программирование С, 2002.
2
Документ
Категория
Рефераты
Просмотров
88
Размер файла
776 Кб
Теги
kursova
1/--страниц
Пожаловаться на содержимое документа