РАЗРАБОТКА ПРОГРАММНОГО СРЕДСТВА С ИСПОЛЬЗОВАНИЕМ МЕТОДОЛОГИИ ООП

Введение
Объектно-ориентированное программирование (ООП) – это парадигма
(совокупность понятий и идей) программирования, в рамках которой
основными ставятся понятия объектов и классов. Сейчас ООП так или иначе
присутствует во всех языках, поэтому понимание его основ просто
необходимо для всех, кто выбрал программирование в качестве профессии.
Появление объектно-ориентированного программирования стало
результатом возросших требований к функционалу программ, когда
количество объектов, с которыми работает программист, стало достаточно
большим, а сами объекты приобрели достаточно высокую сложность
обработки данных. Используемый до этого момента процедурный подход
перестал удовлетворять разработчиков, и результатом стало появление и
развитие новой методологии программирования.

Описание Объектно-Ориентированного Программирования

Важнейшим шагом на пути к совершенствованию языков
программирования стало появление объектно-ориентированного подхода к
программированию и соответствующего класса языков.
Объектно-ориентированное программирование (ООП) - это парадигма
(совокупность понятий и идей) программирования, в рамках которой «во
главу угла» ставят понятия объектов и классов. Сейчас ООП так или иначе
присутствует во всех языках, поэтому понимание его основ просто
необходимо для всех, кто занимается программированием. Наиболее
известным примером объектно-ориентированного языка программирования
является язык C++, развывшийся из императивного языка С. Его прямым
потомком и логическим продолжением является язык С#. Другие примеры
объектно-ориентированных языков программирования: Visual Basic, Java,
Eiffel, Oberon.

4
При объектно-ориентированном подходе программа представляет
собой описание объектов, их свойств (или атрибутов), совокупностей (или
классов), отношений между ними, способов их взаимодействия и операций
над объектами (или методов).
Базовые понятия ООП это класс и объект.
Класс - это шаблон, описание ещё не созданного объекта. Класс
содержит данные, которые описывают строение объекта и его возможности,
методы работы с ним.
Объект - экземпляр класса. То, что «рождено» по «чертежу», то есть по
описанию из класса. В качестве примера объекта и класса можно привести
технический чертёж для изготовления детали - это класс. Выточенная же на
станке по размерам и указаниям из чертежа деталь - объект.
Появление объектно-ориентированного программирования стало
результатом возросших требований к функционалу программ, когда
описывать объект приходилось раз за разом в разных участках кода. Тогда и
было введено понятие класса, параметры которого задавались единожды, а
после в коде оставлялись только ссылки на класс, чтобы код самостоятельно
«собрал» объект.
Несомненным преимуществом данного подхода является
концептуальная близость к предметной области произвольной структуры и
назначения. Механизм наследования атрибутов и методов позволяет строить
производные понятия на основе базовых и таким образом создавать модель
сколь угодно сложной предметной области с заданными свойствами.
В объектно-ориентированном программировании выделяют 4
основных принципа: абстракция, инкапсуляция, наследование и
полиморфизм.
Абстракция — способ выделения самых значимых характеристик
объекта, при этом менее значимые отбрасываются. В ООП абстракция -
работа только со значимыми характеристиками. Суть этого принципа в том,

5
чтобы отделить составные объекты, состоящие из «меньших» объектов, от
этих самых объектов, то есть от их составляющих.
Такой подход позволяет работать непосредственно с объектом, не
вдаваясь в подробности, из чего же он состоит и как работает
Инкапсуляция - принцип объектно-ориентированного
программирования, позволяющий собрать объект в пределах одной
структуры или массива, убрав способ обработки данных и сами данные от
«чужих глаз».
Это одновременно и облегчает конечному пользователю работу с
программой, и защищает данные и само приложение от постороннего
вмешательства. Пользователь может работать со всем функционалом через
интерфейс, не задумываясь над тем, как программа работает. Инкапсуляцию
применяют:
-когда нужно сохранить некоторый участок кода без изменений со
стороны пользователя;
-когда нужно ограничить доступ к коду - в связи с уникальностью
используемых техник, которые автор хочет оставить «при себе»;
-когда изменение кода повлечёт за собой неработоспособность
программы или её взлом.
Наследование — способность в объектно-ориентированном
программировании построить новый класс на основе уже заданного. При
этом функционал может, как полностью совпадать, так и отличаться. Класс-
донор называется в таком случае родительским или базовым, а его «потомок»
— наследником, дочерним классом.
Существует также множественное наследование, при котором у класса-
наследника может быть несколько «родителей». При этом класс наследует
методы всех своих отцов и матерей, что часто приводит к ошибкам.
Наследование требует определения ещё одного понятия:

6
-прототип - объект-образец, на основе которого «рождаются» другие
объекты, полностью копируя его или изменяясь в процессе. При изменении в
прототипе в копиях также происходят соответствующие изменения.
Полиморфизм - способность объектов самим определять, какие методы
они должны применить в зависимости от того, где именно в коде они
находятся. То есть, объект может изменяться в зависимости от своего
местоположения и действовать по-разному, что позволяет не заводить
лишних структур. Иначе говоря: один интерфейс - множество решений.
Полиморфизм позволяет повысить процент повторного использования
кода и сократить тем самым размер программы и временные затраты на её
написание.

7
Объектно-ориентированное программирование, ООП - это методика,
которая концентрирует основное внимание программиста на связях между
объектами, а не на деталях их реализации.
Объект - это абстрактная сущность, наделенная характеристиками
объектов окружающего нас реального мира
Все объектно-ориентированные языки имеют три общие концепции:
инкапсуляцию, полиморфизм и наследование.
Инкапсуляция представляет собой механизм, который связывает
вместе код и данные и который хранит их от внешнего воздействия и от
неправильного использования. Более того, именно инкапсуляция позволяет
создавать объект. Попросту говоря, объект представляет собой логическое
целое, включающее в себя данные и код для работы с этими данными. Мы
можем определить часть кода и данных как собственность объекта, которая
недоступна извне. На этом пути объект обеспечивает существенную защиту
против случайной модификации или некорректного использования таких
частных (private) членов объекта.
Объектно-ориентированные языки программирования поддерживают
полиморфизм, который характеризуется следующей фразой: «один
интерфейс - множество методов». Попросту говоря, полиморфизм
представляет собой атрибут, который позволяет использовать один и тот же
интерфейс при реализации целого класса различных действий. Выбор того,
какое именно действие будет совершено, определяется конкретной
ситуацией.
Полиморфизм помогает уменьшить сложность программы, позволяя
использовать один и тот же интерфейс для задания целого класса действий.
Задача выбора специфического действия (то есть метода) в зависимости от
конкретной ситуации возлагается на компилятор. Программисту нет
необходимости делать такой выбор вручную. Требуется только запомнить и
использовать общий интерфейс.

8
Первые объектно-ориентированные языки программирования были
интерпретаторами, поэтому полиморфизм поддерживался в режиме времени
выполнения. Однако поскольку С++ представляет собой компилятор, то
полиморфизм поддерживается как в режиме времени выполнения, так и на
этапе компиляции.
Наследование представляет собой процесс, благодаря которому один
объект может наследовать, приобретать свойства от другого объекта. Это
свойство поддерживает концепцию классификации, чем и обусловливается
его важность. Эта концепция лежит в основе классификации знаний. На
основе классификации объект нуждается только в определении таких
качеств, которые отличают его от других объектов этого класса. Благодаря
механизму наследования объект может характеризоваться в рамках
классификации общего и частного.
Классы в С++ - это абстракция описывающая методы, свойства, ещё не
существующих объектов. Объекты - конкретное представление абстракции,
имеющее свои свойства и методы. Созданные объекты на основе одного
класса называются экземплярами этого класса. Эти объекты могут иметь
различное поведение, свойства, но все равно будут являться объектами
одного класса.
// объявление классов в С++
class /*имя класса*/
{
private:
/* список свойств и методов для использования внутри класса */
public:
/* список методов доступных другим функциям и объектам
программы */
protected:
/*список средств, доступных при наследовании*/

9
};
Объявление класса начинается с зарезервированного ключевого слова
class, после которого пишется имя класса. В фигурных скобочках,
объявляется тело класса, причём после закрывающейся скобочки обязательно
нужно ставить точку с запятой. В теле класса объявляются три метки
спецификации доступа, после каждой метки нужно ставить двоеточие. В
строке 4 объявлена метка спецификатора доступа private. Все методы и
свойства класса, объявленные после спецификатор доступа private будут
доступны только внутри класса. Все методы и свойства класса, объявленные
после спецификатора доступа public будут доступны другим функциям и
объектам в программе.
Конструктор - специальная функция, которая выполняет начальную
инициализацию элементов данных, причём имя конструктора обязательно
должно совпадать с именем класса. Важным отличием конструктора от
остальных функций является то, что он не возвращает значений вообще
никаких, в том числе и void. В любом классе должен быть конструктор, даже
если явным образом конструктор не объявлен (как в предыдущем классе), то
компилятор предоставляет конструктор по умолчанию, без параметров
В отличии от конструктора, деструктор - специальный метод класса,
который служит для уничтожения элементов класса. Чаще всего его
используют тогда, когда в конструкторе, при создании объекта класса,
динамически был выделен участок памяти и необходимо эту память
очистить, если эти значения уже не нужны для дальнейшей работы
программы.
Важные особенности конструкторов и деструкторов:
-конструктор и деструктор, всегда объявляется в разделе public;
-при объявлении конструктора, тип данных возвращаемого значения не
указывается, в том числе void;

10
-у деструктора также нет типа данных для возвращаемого значения, к
тому же деструктору нельзя передавать никаких параметров;
-имя класса и конструктора должно быть идентично;
-имя деструктора идентично имени конструктора, но с приставкой ~ .
В классе допустимо создавать несколько конструкторов, если это
необходимо. Имена конструкторов будут одинаковыми. Компилятор будет
их различать по передаваемым параметрам.
В классе может быть объявлен только один деструктор.
Объектно-ориентированное программирование - современный подход
к программированию программ и систем, в котором основные операции
совершаются с некими объектами и описывающими их классами. Объектно-
ориентированная программа является совокупностью объектов и способов их
взаимодействия.
Класс - это тип, описывающий устройство объектов. В классах
описываются свойства объекта, его методы и события, на которые он может
реагировать. Объект - это экземпляр класса. Объект можно определить, как
некую совокупность данных и способов работы с ним. При объектно-
ориентированном программировании объект состоит из двух частей: набора
данных (или свойств объекта) и программного кода обработки этих данных
(или методов объекта).
Класс является описываемой на языке терминологии (пространства
имён) исходного кода моделью ещё не существующей сущности, так
называемого объекта.
Объект - сущность в адресном пространстве вычислительной системы,
появляющаяся при создании экземпляра класса (например, после запуска
результатов компиляции (и линковки) исходного кода на выполнение).
Контейнером называется объект, позволяющий хранить и обрабатывать
набор некоторых объектов. Вариантами реализации контейнера могут быть
на основе: массива, динамических списков разных типов, хеш-таблиц.

11
Любая программа в объектно-ориентированном программировании
реализует ту или иную поставленную задачу с помощью взаимодействия
объектов разных классов.
Различают два способа взаимодействия:
-агрегация (композиция);
-обобщение (наследование);
Агрегация возникает в тех случаях, когда один объект включает в себя
в качестве составных частей другие объекты, т.е. моделирует отношение
часть - целое.
Объекты представляют собою упрощенное, идеализированное
описание реальных сущностей предметной области. Если соответствующие
модели адекватны решаемой задаче, то работать с ними оказывается намного
удобнее, чем с низкоуровневым описанием всех возможных свойств и
реакций объекта.
Инкапсуляция - это принцип, согласно которому любой класс должен
рассматриваться как чёрный ящик - пользователь класса должен видеть и
использовать только интерфейсную часть класса (т.е. список декларируемых
свойств и методов класса) и не вникать в его внутреннюю реализацию.
Поэтому данные принято инкапсулировать в классе таким образом, чтобы
доступ к ним по чтению или записи осуществлялся не напрямую, а с
помощью методов. Принцип инкапсуляции (теоретически) позволяет
минимизировать число связей между классами и, соответственно, упростить
независимую реализацию и модификацию классов.
Сокрытие данных - неотделимая часть ООП, управляющая областями
видимости. Является логическим продолжением инкапсуляции. Целью
сокрытия является невозможность для пользователя узнать или испортить
внутреннее состояние объекта.
Наследованием называется возможность порождать один класс от
другого с сохранением всех свойств и методов класса-предка (прародителя,

12
иногда его называют суперклассом) и добавляя, при необходимости, новые
свойства и методы. Набор классов, связанных отношением наследования,
называют иерархией. Наследование может быть двух видов: простое и
множественное.
Наследование называется простым, когда у дочернего класса
существует только один родитель, множественным - когда дочернего класса
существует более одного родителя.
Полиморфизмом называют явление, при котором функции (методу) с
одним и тем же именем соответствует разный программный код
(полиморфный код) в зависимости от того, объект какого класса
используется при вызове данного метода. Полиморфизм обеспечивается тем,
что в классе-потомке изменяют реализацию метода класса-предка с
обязательным сохранением сигнатуры метода. Это обеспечивает сохранение
неизменным интерфейса класса-предка и позволяет осуществить связывание
имени метода в коде с разными классами - из объекта какого класса
осуществляется вызов, из того класса и берётся метод с данным именем.
Такой механизм называется динамическим (или поздним) связыванием - в
отличие от статического (раннего) связывания, осуществляемого на этапе
компиляции.
Переопределение методов - это возможность объявления в дочернем
классе метода, заголовок которого полностью совпадает с родительским
методом, но для этого метода существует своя программная реализация.
Переопределение методов основано на двух важных понятиях:
-динамическая компоновка программного кода, т.е. подключение
необходимых программных модулей непосредственно во время работы
программы.
-информация о переопределенных в классе методах, доступная
механизму динамической компоновки

13
Динамическая компоновка позволяет создавать такие программные
коды, которые могут динамически подключаться в процессе выполнения
программы. Данная программа отличается своей гибкостью, но имеет
достаточно медленную скорость выполнения. Методы данного класса
делятся на две группы: неизменяемые методы (реализация по схеме раннего
связывания), изменяемые переопределенные (виртуальные) методы.
Статическая компоновка - это создание полностью готового к
выполнению программного кода на этапе разработки программы. При
разработки программы компилятор переводит набор программ в машинный
код, а компоновщик объединяет остальные программные модули в единое
целое. Данный код содержит все необходимые адресные связи и может
выполняться без каких - либо дополнительных действий. Преимуществами
этого способа являются быстрая скорость выполнения программного кода, а
недостатком - жесткость программы.
Интерфейсный класс - полностью абстрактный класс, в котором
методы представляют собой только заголовки. Основные значения
интерфейсных классов - это построение гибких объектных моделей с
возможностью создания обычных классов на основе нескольких
интерфейсных классов с обязательной реализацией всех заявленных методов.
Существуют некоторые отличия интерфейсных классов от абстрактных
классов: абстрактные классы могут содержать реализацию некоторых
методов, а в интерфейсных исключена всякая реализация; абстрактные
классы поддерживают только простое наследование, а интерфейсные -
множественное.

Постановка задачи
Целью курсовой работы является разработка приложения для
вычисления площади поверхности цилиндра

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

15
1 СРЕДА РАЗРАБОТКИ ПРОГРАММНОГО ОБЕСПЕЧЕНИЯ
1.1 Описание Microsoft Visual Studio
Для написания программного кода использовалась среда разработки
Visual Studio. Программный код написан на языке C++. Microsoft Visual
Studio – линейка продуктов компании Microsoft, включающих
интегрированную среду разработки программного обеспечения и ряд других
инструментальных средств. Данные продукты позволяют разрабатывать как
консольные приложения, так и приложения с графическим интерфейсом.
Visual Studio включает в себя редактор исходного кода с поддержкой
технологии IntelliSense, встроенный отладчик, редактор форм для упрощения
создания графического интерфейса приложения, веб-редактор, дизайнер
классов и дизайнер схемы базы данных. Назначение .NET Framework -
служить средой для поддержки разработки и выполнения распределенных
компонентных приложений. Она обеспечивает совместное использование
разных языков программирования, а также безопасность, переносимость
программ и общую модель программирования для платформы Windows.

1.2 Описание языка программирования С++
C++ компилируемый, статически типизированный язык программирования о
бщего назначения. Поддерживает такие парадигмы программирования, как
процедурное программирование, объектно-ориентированное
программирование, обобщенное программирование. Язык имеет богатую
стандартную библиотеку, которая включает в себя распространенные
контейнеры и алгоритмы, ввод-вывод, регулярные выражения, поддержку
многопоточности и другие возможности. C++ сочетает свойства как
высокоуровневых, так и низкоуровневых языков. В сравнении с его
предшественником языком C, наибольшее внимание уделено поддержке
объектно-ориентированного и обобщенного программирования. C++ широко

16
используется для разработки программного обеспечения, являясь одним из
самых популярных языков программирования. Область его применения
включает создание операционных систем, разнообразных прикладных
программ, драйверов устройств, приложений для встраиваемых систем,
высокопроизводительных серверов, а также развлекательных приложений
(игр). Существует множество реализаций языка C++, как бесплатных, так и
коммерческих и для различных платформ. Например, на платформе x86 это
GCC, Visual C++, Intel C++ Compiler, Embarcadero (Borland) C++ Builder и
другие. C++ оказал огромное влияние на другие языки программирования, в
первую очередь на Java и C#.

17
2 РАЗРАБОТКА ПРОГРАММНОГО СРЕДСТВА
2.1 Разработка формы приложения
Для реализации поставленной задачи было использования Microsoft
Visual Studio, тип проекта Windows Forms. Выбор Windows Forms обоснован
удобством ввода исходных данных и представления результатов расчета.
Среда разработки Microsoft Visual Studio была выбрана как самая
распространенная в мире интегрированная среда разработки для
программного обеспечения.
Была разработана форма, представленная на рисунке 1.

Рисунок 1 – Форма приложения
На форме размещены 9 элементов управления типа
Textbox,предназначенных для ввода данных и отображения результатов, 11
элементов управления Tlabel, поясняющих содержимое TextBox, и 3
элемента управления TButton. Группы элементов, расположенные в верхней
части формы, используются для ввода исходных данных. Группы элементов,
расположенные в нижней части формы, используются для вывода
результатов расчета. Кнопки используются для выполнения расчета.

18
2.2 Описание классов в программе

В программе описано 2 класса.
В соответствии с заднием, которое сформулировано как «Создать класс
с указанными двумя полями (Радиус окружности основания, Высота
цилиндра) и тремя методами: конструктор для инициализации объекта;
функция формирования строки с информацией об объекте; функция
обработки значений полей) был реализован класс «Цилиндр».
Класс Cylinder содержит:
– поля R и H (Радиус и высота цилиндра), для увеличения точности
расчетов тип полей был выбран double (действительное число с двойной
точностью, обеспечивает минимум 11 десятичных цифр представления
числа);
Два конструктора:
– конструктор по умолчанию
Cylinder();
– конструктор с параметрами
Cylinder(double r, double h) ;
Где
r – радиус основания цилиндра
h – высота цилиндра
Шесть методов:
– метод позволяющий установить значение радиуса окружности
основания
void setR(double r) ;
– метод позволяющий получить значение радиуса окружности
основания
double getR();
– метод позволяющий установить значение высоты цилиндра

19
void setH(double h);
–метод позволяющий получить значение высоты цилиндра
double getH();
– метод позволяющий получить значение площадь
virtual double getS();
– метод возвращающий строковое представление
String^ ToString() override;
Примечание: метод getS() объявлен виртуальным, так как у дочернего
класса также должен одноименный быть метод для получения общей
площади всех цилиндров.
Примечание: метод ToString() перекрывает стандартный метод класса
Object, предназначенный для получения текстового представления объекта. В
дочернем классе от также перекрыт.

Также в соответсвии с заданием, сформулированным как «Создать
дочерний класс с дополнительным полем «Количество одинаковых
цилиндров». Реализовать в дочернем классе методы: конструктор; функцию
обработки данных» был разработан дочерний от класса «Цилиндр» класс
«Цилиндры»

Класс Cylinders является наследником класса Cylinder.
Класс содержит:
– Дополнительное поле N, содержащее целое число «количество
одинаковых цилиндров»
Конструкторы:
– конструктор по умолчанию
Cylinders();
– конструктор с параметрами
Cylinders(double r, double h, int N) ;

20
Где r и h – аналогичны параметрам конструктора класса-предка, а
параметр N – это количество одинаковых цилиндров.
Дополнительные и перекрытые методы:
– метод позволяющий установить количество цилиндров
void setN(int N) ;
– метод позволяющий получить количество цилиндров
double int getN();
– переопределенный метод позволяющий получить значение площадь
virtual double getS();
– метод возвращающий строковое представление
String^ ToString() override;

Примечание. Метод getS() перекрывает виртуальный метод класса-
предка.
Примечание. Метод ToString() перекрывает виртуальный метод класса-
предка и, соответственно, базового класса Object.

Кнопка «Вычислить» для обработки одного цилиндра.
При вызове расчета для одного цилиндра выполняется следующий код:
//чтение исходных данных и вызов конструктора класса
Cylinder^ c = gcnew Cylinder(ReadDouble(textBoxR1),

ReadDouble(textBoxH1));
// расчет площади и вывод результата

textBoxString1->Text = c->ToString();
textBoxS1->Text = c->getS().ToString();

Аналогично выглядит код для вычисления площади множества
цилиндров:

21

Cylinders^ c = gcnew Cylinders(ReadDouble(textBoxR2),

ReadDouble(textBoxH2), ReadInt(textBoxN2));

textBoxString2->Text = c->ToString();
textBoxS2->Text = c->getS().ToString();

Функции ReadDouble и ReadInt используются для проверки
корректности ввода.

22
3 ОПИСАНИЕ РАБОТЫ И ТЕСТИРОВАНИЕ ПС
3.1 Демонстрация интерфейса

Интерфейс программы показан на рисунке 2.

Рисунок 2 – Интерфейс программы

Заполнив необходимые поля, мы можем рассчитать все необходимые
для нас значения.
Если при заполнении исходных данных была допущена ошибка, то
программа выделяет фоновым красным цветом место ошибки, выдает
сообщение о попытке ввода неверных данных и вычислений не производит.
На рисунке 3 показано сообщение, появляющееся при нечисловом
вводе в поле «Радиус основания одного цилиндра»

23
Рисунок 3. Диагностичесое сообщение

И соотвествующее поле ввода окрашивается в красный цвет, как
показано на рисунке 4:

Рисунок 4. Подсветка ошибочного значения.

При попытке ввести недопустимые числовые значения (например,
отрицательное значение радиуса), программа самостоятельно исправляет
ошибку (в данном случае – принимает значение R, равным 0) и производит
вычисление площади. Результат вычисления приведен на рисунке 5.

24
Рисунок 5. Вычисления с неверным значением.

Примеры нормальной работы программы показаны на рисунках 6 и 7.

Рисунок 6 – Результат работы программы (пример 1)

25
Рисунок 7 – Результат работы программы (пример 2)

Рассмотрим подробнее способы проверки правильности ввода.
Ввод действительного значения реализован в методе формы double
ReadDouble(TextBox^ textBox);
Входным параметром функции является экземпляр класса TextBox, в
свойстве Text которого пользователь тем или иным способом ввел некоторую
строку. Эта строка может оказаться как правильной записью действительного
числа (в общем случае в формате «Мантисса»e«Характеристика», при этом
мантисса может содержать разделитель целой и дробной части, принятый в
данной версии ОС и знаки «-» или «+», а характеристика является обычным
целым числом со знаком, по модулю не превышающим предельного для типа
double значения), так и произвольным набором символов. В примере
обработки ошибок, показанном на рисунках 3 и 4, введена строка «не число».
Основная операция метода ReadDouble сводится к попытке
преобразовать текст в действительное число. .Net framework предоставляет
для этого статичсекий метод TryParse класса double.
double::TryParse(textBox->Text, result)

26
Этот метод – функция, которая возвращает логическое значение (true
или false). Значение True возвращается тогда, когда переданная функции
строка представляет собой верную запись действительного числа, и false –
когда запись не верна.
Если запись верна, то второму параметру функции присваивается
действительное значение, которое было записано в текстовом виде в первом
параметре.
Функция ReadDouble, в зависимости от того, было удачным
преобразование или нет, окрашивает TextBox в белый или красный цвет:
textBox->BackColor = Color::Red; //Красный, ошибка
textBox->BackColor = Color::White; //Белый, ошибки нет

Также, если была ошибка, выдается диагностическое сообщение.

Функция ReadInt полностью аналогична функции ReadDouble за
исключением того, что используется метод TryParse класса int, а не double

27
Заключение
Во время выполнения курсовой работы была написана программа на
С++ с помощью объектно-ориентированного программирования (ООП),
которая предназначена для расчета площади поверхности цилиндра.
Программа имеет графический интерфейс. Для решения задачи разработан
класс «Цилиндр» и класс наследник «Цилиндры», позволяющий решить
задачу для N цилиндров. Для программы проведено тестирование на
контрольных значениях. В дальнейшем программу можно улучшить, и
добавить в нее различные методы.

28
Список использованной литературы
1 Страуструп, Б. Язык программирования C++ / Б. Страуструп. – М.:
Радио и связь, 2011. – 350 c.
2  Страуструп, Бьерн Дизайн и эволюция С++ / Бьерн Страуструп. – М.:
ДМК Пресс, 2016. – 446 c.
3 Павловская, Т. С/С++.Процедурное и объектно-ориентированное
программирование / Т. Павловская. - СПб.: Питер, 2018. – 496 c.
4 Пахомов Б. C/C++ и MS Visual C++ 2012 для начинающих / Борис
Пахомов – СПб.: БХВ-Петербург, 2015 – 518с.
5 Халперн Стандартная библиотека С++ / Халперн, Пабло. – М.:
Вильямс, 2014. – 336 c.

29

ПРИЛОЖЕНИЕ А

Блок-схема алгоритма работы программного средства

Начало программы

Ввод исходных
значений

Расчет площади
Поверхности

Вывод
результата

Завершение программы

30

ПРИЛОЖЕНИЕ Б

Листинг кода программного средства

#pragma once
#include "Cylinder.h"
#include "Cylinders.h"
namespace Kurs26 {
using namespace System;
using namespace System::ComponentModel;
using namespace System::Collections;
using namespace System::Windows::Forms;
using namespace System::Data;
using namespace System::Drawing;
/// <summary>
/// Summary for MyForm
/// </summary>
public ref class MyForm : public System::Windows::Forms::Form
{
public:
MyForm(void)
{
InitializeComponent();
//
//TODO: Add the constructor code here
//
}
protected:
/// <summary>
/// Clean up any resources being used.
/// </summary>
~MyForm()
{
if (components)
{
delete components;
}
}
private: System::Windows::Forms::Label^ label1;

31
private: System::Windows::Forms::TextBox^ textBoxR1;
private: System::Windows::Forms::Label^ label2;
private: System::Windows::Forms::Label^ label3;
private: System::Windows::Forms::Label^ label4;
private: System::Windows::Forms::TextBox^ textBoxH1;
private: System::Windows::Forms::Label^ label5;
private: System::Windows::Forms::Label^ label6;
private: System::Windows::Forms::TextBox^ textBoxR2;
private: System::Windows::Forms::TextBox^ textBoxH2;

private: System::Windows::Forms::Label^ label7;
private: System::Windows::Forms::TextBox^ textBoxN2;
private: System::Windows::Forms::Label^ label8;
private: System::Windows::Forms::TextBox^ textBoxS1;
private: System::Windows::Forms::Label^ label9;
private: System::Windows::Forms::TextBox^ textBoxS2;
private: System::Windows::Forms::Button^ button1;
private: System::Windows::Forms::Button^ button2;
private: System::Windows::Forms::Button^ buttonExit;
private: System::Windows::Forms::Label^ label10;
private: System::Windows::Forms::Label^ label11;
private: System::Windows::Forms::TextBox^ textBoxString1;
private: System::Windows::Forms::TextBox^ textBoxString2;
protected:
private:
/// <summary>
/// Required designer variable.
/// </summary>
System::ComponentModel::Container ^components;
#pragma region Windows Form Designer generated code

/// <summary>
/// Required method for Designer support - do not modify
/// the contents of this method with the code editor.
/// </summary>
void InitializeComponent(void)

32

{
this->label1 = (gcnew

System::Windows::Forms::Label());

this->textBoxR1 = (gcnew

System::Windows::Forms::TextBox());

this->label2 = (gcnew

System::Windows::Forms::Label());

this->label3 = (gcnew

System::Windows::Forms::Label());

this->label4 = (gcnew

System::Windows::Forms::Label());

this->textBoxH1 = (gcnew

System::Windows::Forms::TextBox());

this->label5 = (gcnew

System::Windows::Forms::Label());

this->label6 = (gcnew

System::Windows::Forms::Label());

this->textBoxR2 = (gcnew

System::Windows::Forms::TextBox());

this->textBoxH2 = (gcnew

System::Windows::Forms::TextBox());

this->label7 = (gcnew

System::Windows::Forms::Label());

this->textBoxN2 = (gcnew

System::Windows::Forms::TextBox());

this->label8 = (gcnew

System::Windows::Forms::Label());

this->textBoxS1 = (gcnew

System::Windows::Forms::TextBox());

this->label9 = (gcnew

System::Windows::Forms::Label());

this->textBoxS2 = (gcnew

System::Windows::Forms::TextBox());

this->button1 = (gcnew

System::Windows::Forms::Button());

this->button2 = (gcnew

System::Windows::Forms::Button());

this->buttonExit = (gcnew

System::Windows::Forms::Button());

this->label10 = (gcnew

System::Windows::Forms::Label());

this->label11 = (gcnew

System::Windows::Forms::Label());

33

this->textBoxString1 = (gcnew

System::Windows::Forms::TextBox());

this->textBoxString2 = (gcnew

System::Windows::Forms::TextBox());

this->SuspendLayout();
//
// label1
//
this->label1->AutoSize = true;
this->label1->Location = System::Drawing::Point(20,

39);

this->label1->Name = L"label1";
this->label1->Size = System::Drawing::Size(100, 13);
this->label1->TabIndex = 0;
this->label1->Text = L"Радиус основания";
//
// textBoxR1
//
this->textBoxR1->Location =

System::Drawing::Point(141, 36);

this->textBoxR1->Name = L"textBoxR1";
this->textBoxR1->Size = System::Drawing::Size(53, 20);
this->textBoxR1->TabIndex = 1;
this->textBoxR1->Text = L"1";
this->textBoxR1->TextAlign =

System::Windows::Forms::HorizontalAlignment::Right;

//
// label2
//
this->label2->AutoSize = true;
this->label2->Location = System::Drawing::Point(58, 9);
this->label2->Name = L"label2";
this->label2->Size = System::Drawing::Size(78, 13);
this->label2->TabIndex = 0;
this->label2->Text = L"Один цилиндр";
//
// label3
//
this->label3->AutoSize = true;
this->label3->Location = System::Drawing::Point(282,

9);

this->label3->Name = L"label3";
this->label3->Size = System::Drawing::Size(96, 13);
this->label3->TabIndex = 0;

34

this->label3->Text = L"Много цилиндров";
//
// label4
//
this->label4->AutoSize = true;
this->label4->Location = System::Drawing::Point(20,

74);

this->label4->Name = L"label4";
this->label4->Size = System::Drawing::Size(45, 13);
this->label4->TabIndex = 0;
this->label4->Text = L"Высота";
//
// textBoxH1
//
this->textBoxH1->Location =

System::Drawing::Point(141, 71);

this->textBoxH1->Name = L"textBoxH1";
this->textBoxH1->Size = System::Drawing::Size(53, 20);
this->textBoxH1->TabIndex = 1;
this->textBoxH1->Text = L"1";
this->textBoxH1->TextAlign =

System::Windows::Forms::HorizontalAlignment::Right;

//
// label5
//
this->label5->AutoSize = true;
this->label5->Location = System::Drawing::Point(254,

39);

this->label5->Name = L"label5";
this->label5->Size = System::Drawing::Size(100, 13);
this->label5->TabIndex = 0;
this->label5->Text = L"Радиус основания";
//
// label6
//
this->label6->AutoSize = true;
this->label6->Location = System::Drawing::Point(254,

74);

this->label6->Name = L"label6";
this->label6->Size = System::Drawing::Size(45, 13);
this->label6->TabIndex = 0;
this->label6->Text = L"Высота";
//
// textBoxR2

35

//
this->textBoxR2->Location =

System::Drawing::Point(375, 36);

this->textBoxR2->Name = L"textBoxR2";
this->textBoxR2->Size = System::Drawing::Size(53, 20);
this->textBoxR2->TabIndex = 1;
this->textBoxR2->Text = L"1";
this->textBoxR2->TextAlign =

System::Windows::Forms::HorizontalAlignment::Right;

//
// textBoxH2
//
this->textBoxH2->Location =

System::Drawing::Point(375, 71);

this->textBoxH2->Name = L"textBoxH2";
this->textBoxH2->Size = System::Drawing::Size(53, 20);
this->textBoxH2->TabIndex = 1;
this->textBoxH2->Text = L"1";
this->textBoxH2->TextAlign =

System::Windows::Forms::HorizontalAlignment::Right;

//
// label7
//
this->label7->AutoSize = true;
this->label7->Location = System::Drawing::Point(254,

111);

this->label7->Name = L"label7";
this->label7->Size = System::Drawing::Size(66, 13);
this->label7->TabIndex = 0;
this->label7->Text = L"Количество";
//
// textBoxN2
//
this->textBoxN2->Location =

System::Drawing::Point(375, 108);

this->textBoxN2->Name = L"textBoxN2";
this->textBoxN2->Size = System::Drawing::Size(53, 20);
this->textBoxN2->TabIndex = 1;
this->textBoxN2->Text = L"1";
this->textBoxN2->TextAlign =

System::Windows::Forms::HorizontalAlignment::Right;

//
// label8
//

36

this->label8->AutoSize = true;
this->label8->Location = System::Drawing::Point(20,

201);

this->label8->Name = L"label8";
this->label8->Size = System::Drawing::Size(54, 13);
this->label8->TabIndex = 0;
this->label8->Text = L"Площадь";
//
// textBoxS1
//
this->textBoxS1->Location =

System::Drawing::Point(80, 198);

this->textBoxS1->Name = L"textBoxS1";
this->textBoxS1->Size = System::Drawing::Size(114,

20);

this->textBoxS1->TabIndex = 1;
this->textBoxS1->Text = L"\?";
this->textBoxS1->TextAlign =

System::Windows::Forms::HorizontalAlignment::Right;

//
// label9
//
this->label9->AutoSize = true;
this->label9->Location = System::Drawing::Point(254,

204);

this->label9->Name = L"label9";
this->label9->Size = System::Drawing::Size(54, 13);
this->label9->TabIndex = 0;
this->label9->Text = L"Площадь";
//
// textBoxS2
//
this->textBoxS2->Location =

System::Drawing::Point(314, 201);

this->textBoxS2->Name = L"textBoxS2";
this->textBoxS2->Size = System::Drawing::Size(114,

20);

this->textBoxS2->TabIndex = 1;
this->textBoxS2->Text = L"\?";
this->textBoxS2->TextAlign =

System::Windows::Forms::HorizontalAlignment::Right;

//
// button1
//

37

this->button1->Location = System::Drawing::Point(119,

142);

this->button1->Name = L"button1";
this->button1->Size = System::Drawing::Size(75, 23);
this->button1->TabIndex = 2;
this->button1->Text = L"Вычислить";
this->button1->UseVisualStyleBackColor = true;
this->button1->Click += gcnew

System::EventHandler(this, &MyForm::button1_Click);

//
// button2
//
this->button2->Location = System::Drawing::Point(353,

142);

this->button2->Name = L"button2";
this->button2->Size = System::Drawing::Size(75, 23);
this->button2->TabIndex = 2;
this->button2->Text = L"Вычислить";
this->button2->UseVisualStyleBackColor = true;
this->button2->Click += gcnew

System::EventHandler(this, &MyForm::button2_Click);

//
// buttonExit
//
this->buttonExit->Location =

System::Drawing::Point(353, 228);

this->buttonExit->Name = L"buttonExit";
this->buttonExit->Size = System::Drawing::Size(75, 23);
this->buttonExit->TabIndex = 2;
this->buttonExit->Text = L"Выход";
this->buttonExit->UseVisualStyleBackColor = true;
this->buttonExit->Click += gcnew

System::EventHandler(this, &MyForm::buttonExit_Click);

//
// label10
//
this->label10->AutoSize = true;
this->label10->Location = System::Drawing::Point(20,

174);

this->label10->Name = L"label10";
this->label10->Size = System::Drawing::Size(45, 13);
this->label10->TabIndex = 0;
this->label10->Text = L"Объект";
//

38

// label11
//
this->label11->AutoSize = true;
this->label11->Location = System::Drawing::Point(254,

177);

this->label11->Name = L"label11";
this->label11->Size = System::Drawing::Size(45, 13);
this->label11->TabIndex = 0;
this->label11->Text = L"Объект";
//
// textBoxString1
//
this->textBoxString1->Location =

System::Drawing::Point(80, 171);

this->textBoxString1->Name = L"textBoxString1";
this->textBoxString1->Size =

System::Drawing::Size(114, 20);

this->textBoxString1->TabIndex = 1;
this->textBoxString1->Text = L"\?";
this->textBoxString1->TextAlign =

System::Windows::Forms::HorizontalAlignment::Right;

//
// textBoxString2
//
this->textBoxString2->Location =

System::Drawing::Point(314, 174);

this->textBoxString2->Name = L"textBoxString2";
this->textBoxString2->Size =

System::Drawing::Size(114, 20);

this->textBoxString2->TabIndex = 1;
this->textBoxString2->Text = L"\?";
this->textBoxString2->TextAlign =

System::Windows::Forms::HorizontalAlignment::Right;

//
// MyForm
//
this->AutoScaleDimensions = System::Drawing::SizeF(6,

13);

this->AutoScaleMode =

System::Windows::Forms::AutoScaleMode::Font;

this->ClientSize = System::Drawing::Size(448, 273);
this->Controls->Add(this->buttonExit);
this->Controls->Add(this->button2);
this->Controls->Add(this->button1);

39

this->Controls->Add(this->textBoxN2);
this->Controls->Add(this->textBoxH2);
this->Controls->Add(this->textBoxR2);
this->Controls->Add(this->textBoxString2);
this->Controls->Add(this->textBoxS2);
this->Controls->Add(this->textBoxString1);
this->Controls->Add(this->textBoxS1);
this->Controls->Add(this->textBoxH1);
this->Controls->Add(this->label7);
this->Controls->Add(this->label11);
this->Controls->Add(this->textBoxR1);
this->Controls->Add(this->label9);
this->Controls->Add(this->label10);
this->Controls->Add(this->label6);
this->Controls->Add(this->label8);
this->Controls->Add(this->label3);
this->Controls->Add(this->label4);
this->Controls->Add(this->label5);
this->Controls->Add(this->label2);
this->Controls->Add(this->label1);
this->Name = L"MyForm";
this->Text = L"Цилиндры";
this->ResumeLayout(false);
this->PerformLayout();
}
#pragma endregion

//Кнопка "Закончить(Выход)"
private: System::Void buttonExit_Click(System::Object^ sender,

System::EventArgs^ e) {
Close();
}

//Прочитать действительное число с диагностикой

ошибки

double ReadDouble(TextBox^ textBox)
{
double result = 0;
if (double::TryParse(textBox->Text, result))
textBox->BackColor = Color::White;
else
{
textBox->BackColor = Color::Red;

40

MessageBox::Show(textBox->Text + " -- не

число", "Ошибка",
System::Windows::Forms::MessageBoxButtons::OK,
System::Windows::Forms::MessageBoxIcon::Error
);

}
return result;
}
//Целое число
int ReadInt(TextBox^ textBox)
{
int result = 0;
if (int::TryParse(textBox->Text, result))
textBox->BackColor = Color::White;
else
{
textBox->BackColor = Color::Red;
MessageBox::Show(textBox->Text + " -- не

число", "Ошибка",
System::Windows::Forms::MessageBoxButtons::OK,
System::Windows::Forms::MessageBoxIcon::Error
);

}
return result;
}

private: System::Void button1_Click(System::Object^ sender,

System::EventArgs^ e) {

Cylinder^ c = gcnew Cylinder(ReadDouble(textBoxR1),

ReadDouble(textBoxH1));

textBoxString1->Text = c->ToString();
textBoxS1->Text = c->getS().ToString();
}
private: System::Void button2_Click(System::Object^ sender,

System::EventArgs^ e) {

Cylinders^ c = gcnew Cylinders(ReadDouble(textBoxR2),

ReadDouble(textBoxH2), ReadInt(textBoxN2));

textBoxString2->Text = c->ToString();

41

textBoxS2->Text = c->getS().ToString();
}
};
}

42

ПРИЛОЖЕНИЕ В

Код программы(файл Cylinder.h)

#pragma once
using namespace System;
//Класс Цилиндр
public ref class Cylinder
{
private:
protected: //Будет наследник, ему нужен доступ к полям
double r; //Радиус
double h; //Высота
public:
Cylinder()
{
r = 0;
h = 0;
}
Cylinder(double r, double h):Cylinder()
{
setR(r);
setH(h);
}

//Установить значение радиуса окружности основания
void setR(double r)
{
if (r < 0) return; //Радиус положительный!
this->r = r;
}
double getR()
{
return r;
}
//Установить значение высоты цилиндра
void setH(double h)
{
if (h < 0) return; //Радиус положительный!

43

this->h = h;
}
double getH()
{
return h;
}
//Основная функция - площадь поверхности цилиндра
virtual double getS()
{
//Площадь основания
double S1 = Math::PI * r*r;
//Площадь боковой стороны
double S2 = 2 * Math::PI*r * h;
return 2 * S1 + S2;
}
//Перекрытый метод "Строковое представление"
String^ ToString() override
{
return "R = " + r.ToString() + " H=" + h.ToString();
}
};

44

Приложение Г

Код программы(файл Cylinders.h)

#pragma once
#include "Cylinder.h"
ref class Cylinders :
public Cylinder
{
int N;
public:
Cylinders():Cylinder()
{
N = 0;
}
Cylinders(double r, double h, int N) :Cylinder(r,h)
{
setN(N);
}

void setN(int N)
{
if (N < 0) return;
this->N = N;
}
int getN()
{
return N;
}
//Основная функция - площадь поверхности всех цилиндров
double getS() override
{
return Cylinder::getS() * N;
}
String^ ToString() override
{
return Cylinder::ToString() + " N=" + N.ToString();