Разработка абстрактных моделей для данных и способов обработки этих данных является важнейшим компонентом в процессе решения задач с помощью компьютера. Примеры этого мы видим и на низком уровне в повседневном программировании (например, при использовании массивов и связных списков, рассмотренных в ), и на высоком уровне при решении прикладных задач (как при решении задачи связности с помощью леса объединение-поиск в "Введение"). В настоящей лекции рассматриваются абстрактные типы данных ( abstract data type , в дальнейшем АТД), позволяющие создавать программы с использованием высокоуровневых абстракций. Абстрактные типы данных позволяют отделять абстрактные (концептуальные) преобразования, которые программы выполняют над данными, от любого конкретного представления структуры данных и любой конкретной реализации алгоритма.
Все вычислительные системы основаны на уровнях абстракции: определенные физические свойства кремния и других материалов позволяют принять абстрактную модель бита, который может принимать двоичные значения 0-1; затем на динамических свойствах значений определенного набора битов строится абстрактная модель машины; далее, на основе принципа работы машины под управлением программы на машинном языке строится абстрактная модель языка программирования; и, наконец, строится абстрактное понятие алгоритма, реализуемое в виде программы на языке C++. Абстрактные типы данных дают возможность продолжать этот процесс дальше и разрабатывать абстрактные механизмы для определенных вычислительных задач на более высоком уровне, чем это обеспечивается системой C++, разрабатывать абстрактные механизмы , ориентированные на конкретные приложения и подходящие для решения задач в многочисленных прикладных областях, а также создавать абстрактные механизмы более высокого уровня, в которых используются эти базовые конструкции. Абстрактные типы данных предоставляют в наше распоряжение расширяемый до бесконечности набор инструментальных средств для решения все новых и новых задач.
С одной стороны, применение абстрактных конструкций освобождает от забот по их детальной реализации; с другой стороны, когда производительность программы важна, необходимо знать затраты на выполнение базовых операций. Мы используем множество базовых абстракций, встроенных в аппаратные средства компьютера и служащих основой для машинных инструкций; реализуем другие абстракции в программном обеспечении; и используем дополнительные абстракции, предоставляемые написанным ранее системным программным обеспечением. Абстрактные конструкции высокого уровня часто создаются на основе более простых конструкций. На всех уровнях действует один и тот же основной принцип: необходимо найти наиболее важные операции в программах и наиболее важные характеристики данных, а затем точно определить те и другие на абстрактном уровне и разработать эффективные конкретные механизмы для их реализации. В настоящей лекции мы рассмотрим множество примеров применения этого принципа.
Для разработки нового уровня абстракции потребуется (1) определить абстрактные объекты, с которыми необходимо манипулировать, и операции , которые должны выполняться над ними; (2) представить данные в некоторой структуре данных и реализовать операции ; (3) и (самое главное) обеспечить, чтобы эти объекты было удобно использовать для решения прикладных задач. Эти пункты применимы и к простым типам данных, так что базовые механизмы для поддержки типов данных, которые были рассмотрены в "Элементарные структуры данных" , можно адаптировать для наших целей. Однако язык C++ предлагает важное расширение механизма структур, называемое классом ( class ). Классы исключительно полезны при создании уровней абстракции и поэтому рассматриваются в качестве основного инструмента, который используется для этой цели в оставшейся части книги.
Определение 4.1. Абстрактный тип данных (АТД) - это тип данных (набор значений и совокупность операций для этих значений), доступ к которому осуществляется только через интерфейс. Программу, которая использует АТД, будем называть клиентом, а программу, содержащую спецификацию этого типа данных - реализацией.
Именно слово только делает тип данных абстрактным: в случае АТД клиентские программы не имеют доступа к значениям данных никаким другим способом, кроме операций, описанных в интерфейсе. Представление этих данных и функции, реализующие эти операции , находятся в реализации и полностью отделены интерфейсом от клиента. Мы говорим, что интерфейс является непрозрачным: клиент не может видеть реализацию через интерфейс .
В программах на языке C++ это различие обычно проводится немного четче, так как проще всего создать интерфейс , включив в него представление данных , но указав, что клиентским программам не разрешен прямой доступ к данным. Другими словами, разработчики клиентских программ могут знать представление данных , но никоим образом не могут его использовать.
В качестве примера рассмотрим интерфейс типа данных для точек ( программа 3.3) из раздела 3.1 "Элементарные структуры данных" . В этом интерфейсе явно объявляется, что точки представлены как структуры, состоящие из пары чисел с плавающей точкой, обозначаемых x и у. Подобное применение типов данных является обычным в больших системах программного обеспечения: мы разрабатываем набор соглашений о представлении данных (а также определяем ряд связанных с ними операций) и делаем эти правила доступными через интерфейс , чтобы ими могли пользоваться клиентские программы, входящие в состав большой системы. Тип данных обеспечивает согласованность всех частей системы с представлением основных общесистемных структур данных. Какой бы хорошей такая стратегия ни была, она имеет один изъян: если необходимо изменить представление данных , то потребуется изменить и все клиентские программы. Программа 3.3 снова дает нам простой пример: одна из причин разработки этого типа данных - удобство работы клиентских программ с точками, и мы ожидаем, что в случае необходимости у клиентов будет доступ к отдельным координатам точки. Но мы не можем перейти к другому представлению данных (скажем, к полярным координатам, или трехмерным координатам, или даже к другим типам данных для отдельных координат) без изменения всех клиентских программ.
В отличие от этого, программа 4.1 содержит реализацию абстрактного типа данных, соответствующего типу данных из программы 3.3, но с использованием класса языка C++, в котором сразу определены как данные, так и связанные с ними операции . Программа 4.2 является клиентской программой, работающей с этим типом данных. Эти две программы выполняют те же самые вычисления, что и программы 3.3 и 3.8. Они иллюстрируют ряд основных свойств классов, которые мы сейчас рассмотрим.
Когда мы пишем в программе определение наподобие int i, мы указываем системе зарезервировать область памяти для данных (встроенного) типа int , к которой можно обращаться по имени i. В языке C++ для подобных сущностей имеется термин объект . При записи в программе такого определения, как POINT p, говорят, что создается объект класса POINT , к которому можно обращаться по имени p. В нашем примере каждый объект содержит два элемента данных, с именами x и у. Как и в случае структур, к ним можно обращаться по именам вроде p.y.
Элементы данных x и у называются данными-членами класса. В классе могут быть также определены функции-члены, которые реализуют операции , связанные с этим типом данных. Например, класс , определенный в программе 4.1, имеет две функции-члена с именами POINT и distance .
Клиентские программы, такие как программа 4.2, могут вызывать функции-члены, связанные с объектом, указывая их имена точно так же, как и имена данных, находящихся в какой-нибудь структуре struct. Например, выражение p.distance(q) вычисляет расстояние между точками p и q (такое же расстояние должен возвращать и вызов q.distance(p) ). Функция POINT() - первая функция в программе 4.1 - является особой функцией-членом, называемой конструктором: у нее такое же имя, как и у класса, и она вызывается тогда, когда требуется создать объект этого класса.
Программа 4.1. Реализация класса POINT (точка)
В этом классе определен тип данных , который состоит из набора значений, представляющих собой "пары чисел с плавающей точкой" (предполагается, что они интерпретируются как точки на декартовой плоскости), а также две функции-члена, определенные для всех экземпляров класса POINT : функция POINT() , которая является конструктором, инициализирующим координаты случайными значениями от 0 до 1, и функция distance(POINT) , вычисляющая расстояние до другой точки. Представление данных является приватным ( private ), и обращаться к нему или модифицировать его могут только функции-члены. Сами функции-члены являются общедоступными ( public ) и доступны для любого клиента. Код можно сохранить, например, в файле с именем POINT .cxx.
#include
Программа 4.2. Программа-клиент для класса POINT (нахождение ближайшей точки)
Эта версия программы 3.8 является клиентом, который использует АТД POINT , определенный в программе 4.3. Операция new создает массив объектов POINT (вызывая конструктор POINT () для инициализации каждого объекта случайными значениями координат). Выражение a[i].distance(a[j]) вызывает для объекта a[i] функцию-член distance с аргументом a[j] .
#include
Определение POINT p в программе-клиенте приводит к выделению области памяти под новый объект и затем (с помощью функции POINT() ) к присвоению каждому из двух его элементов данных случайного значения в диапазоне от 0 до 1.
Этот стиль программирования, который иногда называется объектно-ориентированным программированием, полностью поддерживается конструкцией class языка C++. Класс можно считать расширением понятия структуры, где не только объединяются данные, но и определяются операции с этими данными. Может существовать много разных объектов, принадлежащих одному классу, но все они подобны в том, что их данные-члены могут принимать один и тот же набор значений, и с этими данными-чле-нами может выполняться одна и та же совокупность операций - в общем, это экземпляры одного и того же типа данных. В объектно-ориентированном программировании объекты предназначены для обработки своих данных-членов (в отличие от использования независимых функций для обработки данных, хранимых в объектах).
Мы рассматриваем описанный выше пример небольшого класса просто чтобы познакомиться с основными чертами классов; поэтому он далеко не полон. В реальном коде для класса точки у нас будет намного больше операций. Например, в программе 4.1 отсутствуют даже операции , позволяющие узнавать значения координат x и y . Как мы увидим, добавление этих и других операций - довольно простая задача. В части 5 мы более подробно рассмотрим классы для точки и других геометрических абстракций, например, линий и многоугольников.
В языке C++ (но не в С) у структур также могут быть связанные с ними функции. Ключевое различие между классами и структурами связано с доступом к информации, который характеризуется ключевыми словами
Доброго времени суток, хабравчане!
Следующий пост является изложением моих размышлений на тему природы классов и АТД. Эти размышления дополнены интересными цитатами из книг гуру разработки программного обеспечения
Введение
Начнем с того, что плавно подойдем к определению АТД. АТД, в первую очередь, представляет собой тип данных, что означет следущее:наличие определенных доступных операций над элементами этого типа;
а также данные, относительно которых эти операции выполняются (диапазон значений).
Что же означает слово “абстрактный”? В первую очередь понятие “абстрактность” означет сосредоточение внимания на чем-то важном и, при этом, нам нужно отвлечься от неважных, на данный момент, деталей. Определение абстрактности хорошо раскрыто в книге Гради Буча (“Grady Booch”). Звучит определение так:
Абстракция – это выделение и придание совокупности объектов общих свойств, которые определяют их концепутальные границы и отличают от всех других видов объектов.
Иными словами, абстракция позволяет “пролить свет” на нужные нам данные объектов и, при этом, “затенить” те данные, которые нам не важны.
Итак, что же будет, если слить понятия “тип данных” и “абстракция” воедино? Мы получим тип данных, который предоставляет нам некий набор операций, обеспечивающих поведение объектов этого типа данных, а также этот тип данных будет скрывать те данные, с помощью которых реализовано данное поведение. Отсюда, приходим к понятию АТД:
АТД – это такой тип данных, который скрывает свою внутреннюю реализацию от клиентов.
Удивительно то, что путем применения абстракции АТД позволяет нам не задумываться над низкоуровневыми деталями реализации, а работать с высокоуровневой сущностью реального мира (Стив Макконнелл).
Я считаю, что при разработке АТД сначала нужно определить интерфейс, так как интерфейс не должен зависеть от внутреннего представления данных в АТД. После определения операций, сотставляющих интерфейс, нужно сосредоточиться на данных, которые и будут реализовать заданное поведение АТД. В итоге мы получим некую структуру данных – механизм позволяющий хранить и обрабатывать данные. При этом, прелесть АТД в том, что если нам захочется изменить внутренне представление данных, то нам не придется блуждать по всей программе и менять каждую строку кода, которая зависит от данных, которые мы хотим поменять. АТД инкапсулирует эти данные, что позволяет менять работу объектов этого типа, а не всей программы.
Преимущества АТД
Использование АТД имеет массу преимуществ (все описанные преимущества можно найти в книге Стива Макконнелла «Совершенный код”):
- Инкапсуляция деталей реализации.
Это означает, что единожды инкапсулировав детали реализации работы АТД мы предоставляем клиенту интерфейс, при помощи которого он может взаимодействовать с АТД. Изменив детали реализации, представление клиентов о работе АТД не изменится.
- Снижение сложности.
Путем абстрагирования от деталей реализации, мы сосредатачиваемся на интерфейсе, т.е на том, что может делать АТД, а не на том как это делается. Более того, АТД позволяет нам работать с сущностью реального мира.
- Ограничение области использования данных.
Используя АТД мы можем быть уверены, что данные, представляющие внутреннюю структуру АТД не будут зависеть от других участков кода. При этом реализуется “независимость” АТД.
- Высокая информативность интерфейса.
АТД позволяет представить весь интерфес в терминах сущностей предметной области, что, согласитесь, повышает удобочитаемость и информативность интерфейса.
Стив Макконнелл рекомендует представлять в виде АТД низкоуровнеые типы данных, такие как стек или список. Спросите себя, что представляет собой этот список. Если он представляет список сотрудников банка, то и рассматривайте АТД как список сотрудников банка.
Итак, мы разобрались, что такое АТД и назвали преимущества его применения. Теперь стоит отметить, что при разработке классов в ООП следует думать, в первую очередь, об АТД. При этом, как сказал Стив МакКоннелл, Вы программируете не на языке, а с помощью языка. Т.е Вы будете программировать выходя за рамки языка, не ограничиваясь мыслями в терминах массивов или простых типов данных. Вместо этого Вы будете думать на высоком уровне абстракции (например, в терминах электронных таблицах или списков сотрудников). Класс – это не что иное как дополнение и способ реализации концепции АТД. Мы можем даже представить класс в виде формулы:
Класс = АТД + Наследование + Полиморфизм.
Так почему же следут думать об АТД, при разработке классов. Потому что, сперва мы должны решить какие операции будут составлять интерфейс будущего класса, какие данные скрыть, а к каким предоставить открытый доступ. Мы должны подумать об обеспечении высокой информативности интерфейса, легкости оптимизации и проверки кода, а также о том, как бы нам предоставить правильную абстракцию, чтобы можно было думать о сущностях реального мира, а не о низкоуровнеых деталях реализации. Я считаю, что именно после определения АТД мы должны думать о вопросах наследования и полиморфизма.
Стоит отметить, что концепция АТД нашла гирокое применение в ООП, т.к именно эта концепция дополняет ООП и позволяет уменшить сложность программ в быстроменяющемся мире требований к ПО.
Данную статью я писал для того, что бы обратить внимание разработчиков на АТД с целью повышения качества работы и разработки программного обеспечения.
Использованные источники:
Стив Макконнелл – “Совершенный код”;
Роберт Седжвик – «Алгоритмы на Java».
Абстрактным принято называть тип данных, в явном виде не имеющийся в языке программирования, в этом смысле это понятие относительное - тип данных, отсутствующий в одном языке программирования, может присутствовать в другом.
Абстрактный тип данных (АТД) определяется независимо от способа его реализации:
множеством возможных значений этого типа,
и набором операций со значениями этого типа.
Использование АТД может быть ограничено этапом разработки программного обеспечения, но для его явного использования в программе надо иметь его реализацию на основе уже имеющихся (и ранее реализованных) типов данных в языке программирования:
способ представления значений этого типа,
и реализацию операций со значениями этого типа.
АТД не является предопределенным в языке программирования, и даже более того – операции конструирования таких типов, предопределенные в языке, перекладывают на разработчика-программиста вопрос о способе представления значений такого типа и реализации операций со значениями этого типа. А потому, для таких типов данных вопрос о выборе определений и способов реализации операций вида конструктор (значений и хранилищ данных) такого типа, селектор и модификатор компонентов (значений и хранилищ данных) такого типа возлагается на разработчика-программиста.
В концепции АТД особый статус имеют понятия интерфейс , открытый пользователю, и реализация , скрытая от него. Особая роль этих понятий в концепции АТД связана с основополагающим положением о независимости понятия АТД от способа его реализации.
В современных «практических языках программирования» для конструирования АТД обычно используется предопределенная операция конструирования типов class , которая дает разработчику-программисту не только средства группировки данных и операций (с этими данными) в единое целое, но и средства инкапсуляции, наследования и полиморфизма для управления способами конструирования и доступа к таким данным. Отметим, что класс описывает одну возможную реализацию АТД, отображение класса в АТД выражается функцией абстракции, но обратное отношение, обычно, не является функциональным, реализаций одного и того же АТД может быть несколько.
В исследованиях по абстрактным типам данных уже на раннем этапе была осознана важная роль понятия «параметризация типа ». Действительно, например АТД «Стек» не зависит от типа элементов стека, но реализовать этот АТД указанием на «элементы какого-то одинакового типа» невозможно. В язык программирования Ada соответствующие средства конструирования параметризованных типов данных были включены изначально, а в современных «практических языках программирования» какие средства появились только со времен появления разработки по STL-библиотеке . На сегодня понятие «обобщенное программирование» занимает значимое положение в практическом программировании благодаря включению в «практические языки программирования» средств конструирования параметризованных типов данных (шаблоны, template , generic) .
Всё вышесказанное означает, что с методологической и теоретической точки зрения необходимо более детальное точное определение понятия «абстрактный тип данных». В теории понятие «абстрактный тип данных» обычно определяется как многосортная (многоосновная) алгебраическая система , в которой дополнительно к множеству возможных значений (носителю) и набору операций над такими значениями выделены понятия:
Сорт и сигнатура – эти понятия позволяют расклассифицировать и элементы носителя и операции с ними по их типам (для операций - по типам их аргументов и возвращаемого значения).
Предикаты – отношения на элементах носителя. Это позволяет определять область возможных значений наложением ограничений (требований) на допустимые значения, а также в естественной трактовке работать с произвольными логическими выражениями, не принуждая интерпретировать их как функции принадлежности для множеств или как многозначные операции.
На такой основе можно рассматривать абстрактные типы данных с единой целостной логико-алгебраической точки зрения, включая вопросы о конструкторах (типов и значений), селекторах и модификаторах свойств для объектов такого типа .
Понятия «структура данных» и «абстрактный тип данных» в чем-то очень близкие. Можно конечно считать, что эти понятия - просто два взгляда на одно и то же. Способ представления значений АТД всегда основан на некоторой структуре данных, менее или более сложной, и реализация операций с такими значениями естественно зависит от этой выбранной структуры данных. С другой стороны, заинтересовавшую нас структуру данных при большом желании мы всегда можем оформить как АТД.
Но все же мы будем различать эти два понятия, учитывая:
Абстрактный тип данных - подразумевает определенный уровень абстрагирования с целью фиксации прикладного (предметно-ориентированного) типа данных безотносительно к способам его реализации, и возможно включения этого типа данных в прикладную библиотеку, ну хотя бы для конкретной разработки конкретной программной системы. АТД может иметь несколько альтернативных реализаций, основанных на различных структурах данных.
Структура данных - скорее некоторая схема организации данных и управления ими, которая предполагает соответствующие конкретизации при ее использовании в конкретных ситуациях при решении конкретных задач.
К абстрактным типам данных прежде всего естественно относятся математические базовые алгебраические системы – последовательности, множества, отношения и отображения (функциональные отношения, функции) . Но в программировании на переднем плане не исследование общих свойств этих математических понятий, а возможности их использования в разработке моделей решения задач предметной области, алгоритмов решения этих задач и эффективной реализации разработанных алгоритмов. А потому в программировании в виде АТД обычно оформляются с одной стороны ограниченные варианты этих базовых алгебраических систем, а с другой стороны расширенные специализированными наборами операций, представляющими прагматический интерес с точки зрения области применения.
Министерство Образования и Науки Российской Федерации
Федеральное государственное бюджетное образовательное учреждение
высшего профессионального образования
НАЦИОНАЛЬНЫЙ ИССЛЕДОВАТЕЛЬСКИЙ ЯДЕРНЫЙ УНИВЕРСИТЕТ «МИФИ»
Димитровградский инженерно-технологический институт
Кафедра Информационные технологии
К защите допустить «» 2012 г.
Зав. кафедрой Ракова О.А.
Курсовая работа
по дисциплине «Объектно-ориентированное программирование»
Тема: «Абстрактные типы данных. Списки»
Выполнил: студент гр. ВТ-31
Шаяков А.Ф.
Руководитель: ст. преподаватель кафедры ИТ
Аленин В. А.
Нормоконтролер: ст. преподаватель кафедры ИТ
Аленин В. А.
Оценка:
Дата защиты:
Димитровград, 2012
Министерство Образования и Науки Российской Федерации
Федеральное государственное бюджетное образовательное учреждение
высшего профессионального образования
НАЦИОНАЛЬНЫЙ ИССЛЕДОВАТЕЛЬСКИЙ ЯДЕРНЫЙ УНИВЕРСИТЕТ «МИФИ»
Димитровградский инженерно-технологический институт
на курсовую работу
Дисциплина: Объектно-ориентированное программирование
Тема: Абстрактные типы данных. Списки
Исполнитель: Шаяков А.Ф.
Руководитель: Аленин В.А.
1.Теоретическая часть:
Абстрактные типы данных. Понятие объектно-ориентированного программирования. Линейные односвязные списки.
2.Практическая часть:
На языке С++ написать программу с объектно-ориентированной структурой для реализации линейных односвязных списков.
Сроки выполнения работы по графику:
Теоретическая часть - 15% к 5 неделе
Практическая часть – 80% к 7 неделе
Экспериментальный раздел - ____% к ____ неделе
Защита – 100% к 10 неделе
Требования к оформлению:
Расчетно-пояснительная записка курсовой работы должна быть представлена электронной и твердой копиях;
Объем отчета должен быть не менее 20 машинописных страниц без учета приложений
РПЗ подписывается у ответственного за нормоконтроль
Руководитель работы _________________
Исполнитель ________________________
Дата выдачи «_____» ___________ 2012 г.
ШАЯКОВ А.Ф.ТЕМА: АБСТРАКТНЫЕ ТИПЫ ДАННЫХ. СПИСКИ, Курсовая работа/ ДИТИ,№230105.65-Димитровград, 2012. - 29 стр., рис. 11, библ. назв. 10, приложений 1.
Ключевые слова: линейные односвязные списки, С++, объектно-ориентированное программирование.
Объект исследования – линейные односвязные списки.
Цель работы – исследовав линейные односвязные списки, написать на языке С++ программу с объектно-ориентированной структурой для их реализации.
Выводы: в данной работе была полностью изучены линейные односвязные списки, а также методы их представления в памяти. Написанная на языке С++ программа полностью соответствует объектно-ориентированной структуре, корректно и качественно выполняет свою основную задачу - реализует линейные односвязные списки.
Введение 6
1 Теоретическая часть 7
1.1 Абстрактные типы данных. Линейные списки 7
1.2 Понятие объектно-ориентированного программирования 8
2 Практическая часть 15
3 Тестирование 23
Заключение 25
Список литературы 26
Приложение A 27
Введение
Часто в процессе работы с данными невозможно определить, сколько памяти потребуется для их хранения, память следует распределять во время выполнения программы по мере необходимости отдельными блоками. Блоки связываются друг с другом с помощью указателей. Такой способ организации данных называется динамической структурой данных, поскольку она размещается в динамической памяти и ее размер изменяется во время выполнения программы.
Из динамических структур в данной работе используются линейные списки. Динамическая структура, в отличие от массива или записи, может занимать несмежные участки оперативной памяти.
Динамические структуры широко применяют и для более эффективной работы с данными, размер которых известен, особенно для решения задач сортировки.
Элемент любой динамической структуры состоит из двух частей: информационной, ради хранения которой и создается структура, и указателей, обеспечивающих связь элементов друг с другом.
Теоретическая часть
1.1Абстрактные типы данных. Линейные списки
Понятие абстрактных типов данных является ключевым в программировании. Абстракция подразумевает разделение и независимое рассмотрение интерфейса и реализации.
Абстракция данных предполагает определение и рассмотрение абстрактных типов данных (АТД) или, что то же самое, новых типов данных, введенных пользователем.
Абстрактный тип данных - это совокупность данных вместе с множеством операций, которые можно выполнять над этими данными.
Линейные списки
В линейном списке каждый элемент связан со следующим и, возможно, с предыдущим. В первом случае список называется односвязным, во втором - двусвязным. Если последний элемент связать указателем с первым, получится кольцевой список.
Каждый элемент списка содержит ключ, идентифицирующий этот элемент. Ключ обычно бывает либо целым числом, либо строкой и является частью поля данных. В качестве ключа в процессе работы со списком могут выступать разные части поля данных. Ключи разных элементов списка могут совпадать.
Над списками можно выполнять следующие операции:
начальное формирование списка (создание первого элемента);
добавление элемента в конец списка;
чтение элемента с заданным ключом;
вставка элемента в заданное место списка (до или после элемента с заданным ключом);
удаление элемента с заданным ключом;
упорядочивание списка по ключу.
Для работы со списком в программе требуется определить указатель на его начало. Чтобы упростить добавление новых элементов в конец списка, можно также завести указатель на конец списка.
1.2Понятие объектно-ориентированного программирования
По определению авторитета в области объектно-ориентированных методов разработки программ Гради Буча «объектно-ориентированное программирование (ООП) – это методология программирования, которая основана на представлении программы в виде совокупности объектов, каждый из которых является реализацией определенного класса (типа особого вида), а классы образуют иерархию на принципах наследуемости».
Объектно-ориентированная методология так же, как и структурная методология, была создана с целью дисциплинировать процесс разработки больших программных комплексов и тем самым снизить их сложность и стоимость.
Объектно-ориентированная методология преследует те же цели, что и структурная, но решает их с другой отправной точки и в большинстве случаев позволяет управлять более сложными проектами, чем структурная методология.
Как известно, одним из принципов управления сложностью проекта является декомпозиция. Гради Буч выделяет две разновидности декомпозиции: алгоритмическую (так он называет декомпозицию, поддерживаемую структурными методами) и объектно-ориентированную, отличие которых состоит, по его мнению, в следующем: «Разделение по алгоритмам концентрирует внимание на порядке происходящих событий, а разделение по объектам придает особое значение факторам, либо вызывающим действия, либо являющимся объектами приложения этих действий».
Другими словами, алгоритмическая декомпозиция учитывает в большей степени структуру взаимосвязей между частями сложной проблемы, а объектно-ориентированная декомпозиция уделяет больше внимания характеру взаимосвязей.
На практике рекомендуется применять обе разновидности декомпозиции: при создании крупных проектов целесообразно сначала применять объектно-ориентированный подход для создания общей иерархии объектов, отражающих сущность программируемой задачи, а затем использовать алгоритмическую декомпозицию на модули для упрощения разработки и сопровождения программного комплекса .
ОО-программирование является, несомненно, одним из наиболее интересных направлений для профессиональной разработки программ.
Объекты и классы
Базовыми блоками объектно-ориентированной программы являются объекты и классы. Содержательно объект можно представить как что-то ощущаемое или воображаемое и имеющее хорошо определенное поведение. Таким образом, объект можно либо увидеть, либо потрогать, либо, по крайней мере, знать, что он есть, например, представлен в виде информации, хранимой в памяти компьютера. Дадим определение объекта, придерживаясь мнения ГрадиБуча: «Объект – осязаемая сущность, которая четко проявляет свое поведение».
Объект - это часть окружающей нас реальности, т. е. он существует во времени и в пространстве (впервые понятие объекта в программировании введено в языке Simula). Формально объект определить довольно трудно. Это можно сделать через некоторые свойства, а именно: объект имеет состояние, поведение и может быть однозначно идентифицирован (другими словами, имеет уникальное имя).
Класс - это множество объектов, имеющих общую структуру и общее поведение. Класс - описание (абстракция), которое показывает, как построить существующую во времени и пространстве переменную этого класса, называемую объектом. Смысл предложений «описание переменных класса» и «описание объектов класса» один и тот же .
Объект имеет состояние, поведение и паспорт (средство для его однозначной идентификации); структура и поведение объектов описаны в классах, переменными которых они являются.
Определим теперь понятия состояния, поведения и идентификации объекта.
Состояние объекта объединяет все его поля данных (статический компонент, т.е. неизменный) и текущие значения каждого из этих полей (динамический компонент, т.е. обычно изменяющийся).
Поведение выражает динамику изменения состояний объекта и его реакцию на поступающие сообщения, т.е. как объект изменяет свои состояния и взаимодействует с другими объектами .
Идентификация (распознавание) объекта - это свойство, которое позволяет отличить объект от других объектов того же или других классов. Осуществляется идентификация посредством уникального имени (паспорта), которым наделяется объект в программе, впрочем как и любая другая переменная.
Выше уже говорилось, что процедурный (а также и модульный) подход позволяет строить программы, состоящие из набора процедур (подпрограмм), реализующих заданные алгоритмы. С другой стороны, объектно-ориентированный подход представляет программы в виде набора объектов, взаимодействующих между собой. Взаимодействие объектов осуществляется через сообщения. Предположим, что нашим объектом является окружность. Тогда сообщение, посланное этому объекту, может быть следующим: «нарисуй себя». Когда мы говорим, что объекту передается сообщение, то на самом деле мы вызываем некоторую функцию этого объекта (компонент-функцию). Так, в приведенном выше примере мы вызовем функцию, которая будет рисовать окружность на экране дисплея .
Инкапсуляция
Инкапсуляция - один из основополагающих принципов объектно-ориентированного программирования, идея которого заключается в том, что все свойства и методы объединены в рамках некоторого объекта.
Само название термина "инкапсуляция" происходит от английского слова encapsulate, которое в дословном переводе означает "запечатывать в капсулу" или "покрывать оболочкой". Таким образом объект (капсула) заключает в себе методы и свойства (содержимое) .
Понятие инкапсуляции может быть рассмотрено в более широком смысле, далеко выходящим за рамки объектно-ориентированного программирования в целом. Если говорить о инкапсуляции на максимально возможном уровне абстракции, тогда инкапсуляцию можно представить как способность объекта заключать в себе некое множество других объектов. Так применительно к компьютерной программе можно сказать, что она инкапсулирует в себе несколько модулей, каждый из которых в свою очередь инкапсулирует какие-то объекты, которые инкапсулируют в себе методы и свойства, которые, кстати, тоже могут быть объектами, и так далее .
Исходя из всего вышеописанного, еще одним представлением инкапсуляции может считаться любая древовидная структура, в которой любой узел дерева инкапсулирует в себе всех своих непосредственных детей, которые могут быть как листьями (примитивы, который не могут ничего в себе инкапсулировать) так и другими узлами.
И все же, если говорить о объектно-ориентированном программировании, тогда инкапсуляция - объединение данных и методов в рамках объекта.
Иногда говоря о инкапсуляции в объектно-ориентированном программировании понятие инкапсуляции приравнивается к понятию "черного ящика" или сокрытию данных, однако это не одно и то же. Да, в некоторых объектно-ориентированных языках программирования при помощи инкапсуляции разработчик может сделать свой объект черным ящиком, однако это реализуется при помощи модификаторов доступа, которые есть не во всех объектно-ориентированных языках программирования. Само понятие инкапсуляции намного шире. И даже более того, мы может все свойства и методы сделать доступными из вне, то есть ни о каком черном ящике и речи идти не может, однако инкапсуляция все еще будет присутствовать в любом объекте. Поэтому сокрытие данных по средствам модификаторов доступа является следствием инкапсуляции но никак не являются тождественно равными понятиями .
Во-первых благодаря инкапсуляции объекты перестали быть просто пользовательскими структурами данных, основная цель которых просто быть логически объединить несколько отдельных типов данных в рамках нового составного типа данных. Благодаря инкапсуляции каждый объект теперь может содержать в себе данные, описывающие состояние объекта, и свое поведение, описанное в виде методов. Другими словами объект в объектно-ориентированном программировании перестал быть примитивным пассивным типом данных, управление которым полностью отдано на откуп внешней среде, но стал обладать собственным поведением, можно даже сказать, некоторой волей и разумом, способностью активно реагировать на внешние воздействия и изменять свое состояние и по своим собственным законам и правилам.
Во-вторых, инкапсуляция дает нам возможность контролировать доступ к данным объекта. Ограничение видимости можно так же рассматривать, как проявление собственной воли объекта - объект сам решает, что из своего поведения или свойств сделать доступным для всех, что сделать доступным только для определенного круга объектов, а что и вовсе сделать сугубо интимным, о чем не будет знать ни один другой объект. Зачем, да за тем, что только сам объект точно знает, как с ним можно работать а как нет. Можно даже сказать о новой философии программирования, где объекты более на предметы, над которыми производятся некоторые действия, а, если можно так сказать, новая форма абстрактного синтетического разума, взаимодействуя с которой можно достичь нужного результата.
И еще раз повторюсь, что именно благодаря инкапсуляции объект может быть наделен некоторой волей, разумом, способностью реагировать на внешние воздействие, а не быть пассивным хранилищем данных.
Наследование
Наследование - один из четырёх важнейших механизмов объектно-ориентированного программирования (наряду с инкапсуляцией, полиморфизмом и абстракцией), позволяющий описать новый класс на основе уже существующего (родительского), при этом свойства и функциональность родительского класса заимствуются новым классом.
Другими словами, класс-наследник реализует спецификацию уже существующего класса (базовый класс). Это позволяет обращаться с объектами класса-наследника точно так же, как с объектами базового класса
Типы наследования
Простое наследование
Класс, от которого произошло наследование, называется базовым или родительским (англ. baseclass). Классы, которые произошли от базового, называются потомками, наследниками или производными классами (англ. derivedclass).
В некоторых языках используются абстрактные классы. Абстрактный класс - это класс, содержащий хотя бы один абстрактный метод, он описан в программе, имеет поля, методы и не может использоваться для непосредственного создания объекта. То есть от абстрактного класса можно только наследовать. Объекты создаются только на основе производных классов, наследованных от абстрактного.
Например, абстрактным классом может быть базовый класс «сотрудник вуза», от которого наследуются классы «аспирант», «профессор» и т. д. Так как производные классы имеют общие поля и функции (например, поле «год рождения»), то эти члены класса могут быть описаны в базовом классе. В программе создаются объекты на основе классов «аспирант», «профессор», но нет смысла создавать объект на основе класса «сотрудник вуза» .
Множественное наследование
При множественном наследовании у класса может быть более одного предка. В этом случае класс наследует методы всех предков. Достоинства такого подхода в большей гибкости. Множественное наследование реализовано в C++. Из других языков, предоставляющих эту возможность, можно отметить Python и Эйфель. Множественное наследование поддерживается в языке UML.
Множественное наследование - потенциальный источник ошибок, которые могут возникнуть из-за наличия одинаковых имен методов в предках. В языках, которые позиционируются как наследники C++ (Java, C# и др.), от множественного наследования было решено отказаться в пользу интерфейсов. Практически всегда можно обойтись без использования данного механизма. Однако, если такая необходимость все-таки возникла, то, для разрешения конфликтов использования наследованных методов с одинаковыми именами, возможно, например, применить операцию расширения видимости - «::» - для вызова конкретного метода конкретного родителя.
Попытка решения проблемы наличия одинаковых имен методов в предках была предпринята в языке Эйфель, в котором при описании нового класса необходимо явно указывать импортируемые члены каждого из наследуемых классов и их именование в дочернем классе.
Большинство современных объектно-ориентированных языков программирования (C#, C++, Java, Delphi и др.) поддерживает возможность одновременно наследоваться от класса-предка и реализовать методы нескольких интерфейсов одним и тем же классом. Этот механизм позволяет во многом заменить множественное наследование - методы интерфейсов необходимо переопределять явно, что исключает ошибки при наследовании функциональности одинаковых методов различных классов-предков.
Практическая часть
Для решения поставленной задачи используется объектно-ориентированная структура программы. Программа представлена двумя классами и основным cpp-файлом, содержащим пользовательский интерфейс для удобства работы со списками.
Класс cList представляет собой линейный односвязный список, состоящий из объектов класса cElement.
Класс cElement имеет следующую структуру:
cElement *next;
~cElement(void);
void setdata (int);
void setref (cElement*);
cElement* getref ();
Поле data типа int содержит числовое значение элемента списка, поле next типа cElement* - ссылку на следующий элемент списка. Методы setdata и getdata используются для доступа к приватному полю data класса с целью получения и соответственно установки значения данного поля. Метод setref используется для установки ссылки с текущего на следующий элемент списка, а getref – для перехода на следующий элемент.
void cElement::setdata(int sd)
int cElement::getdata()
returnthis->data;
void cElement::setref(cElement* rf)
cElement* cElement::getref()
returnthis->next;
Реализация данных методов исключительно проста, что видно из их программных кодов, представленных выше.
Теперь рассмотрим структуру класса cList
#include"cElement.h"
cElement *head;
void Add (int);
void Insert(int, int);
void Remove(int);
void RemoveAll();
Данный класс содержит ссылку на головной элемент списка - head, типа cElement*. Хранение данной ссылки необходимо для корректного выполнения операций добавления, удаления данных и печати списка. Дело в том что, при выполнении любой из вышеуказанных операций, происходит перебор элементов списка, чтобы дойти до нужного, так как список не имеет произвольного доступа к элементам, поэтому перебор рациональней начинать с "головы" списка. Кроме ссылки на начало списка, каждый объект данного класса будет иметь поле elcount, которое содержит количество элементов списка.
Продолжим рассмотрение данного класса с изучения методов, реализованных в нем, для работы со списками.
Метод Add - добавление данных в конец списка.
В качестве параметра данный метод принимает числовое значение (переменная xd), которое нужно сохранить в добавляемый элемент списка.
void cList::Add(int xd)
Так происходит создание нового элемента и установка значения его числового поля:
cElement *temp = newcElement;
temp->setdata(xd);
После осуществляется проверка количества элементов списка, если список пуст, то создается головной элемент, иначе "рядовой" компонент списка:
if (elcount ==0)
temp->setref(NULL);
temp->setref(NULL);
p->setref(temp);
Можно заметить, что в вышеуказанной конструкции используется метод setref класса cElement, который необходим для установки ссылки на следующий элемент списка, иначе список будет несвязанным, что чревато потерей данных и некорректной работы программы.
При первом запуске программы, описанный выше метод, используется для последовательного добавления элементов в список, с которым затем можно работать, для остановки ввода в командной строке необходимо вместо числового значения элемента ввести команду "stop" (см. рисунок 1).
Рисунок 1 – Процесс добавления элементов в список
После ввода команды "stop", происходит печать списка и программа переходит в режим ожидания команды (см. рисунок 2).
Рисунок 2 – Распечатанный список
Метод Print - печать списка.
Для печати важно знать начало списка, чтобы последовательно распечатать значения всех элементов списка, поэтому в переменную temp устанавливается ссылка на "голову" списка, после чего проверяется факт существования списка и выводится соответствующие сообщение, если он не подтверждается, если же список не пуст, то он выводится на экран:
void cList::Print()
cElement * temp = head;
if (temp == NULL) cout while(temp != NULL)
temp = temp->getref();
Метод Del - удаление начального элемента списка.
Для удаления начального элемента необходимо сначала перенести ссылку на следующий компонент списка, сделав его первым таким образом и затем уже удалить требуемый элемент:
voidcList::Del()
cElement * temp = head;
head = head->getref();
Метод RemoveAll - удаление всего списка.
Данный метод основан на вышеуказанном и заключается в последовательном удалении начальных элементов списка, пока не будет удален весь список.
void cList::RemoveAll()
while (elcount!=0)
Для запуска данного метода, в меню работы со списком необходимо ввести команду "dellist" (см. рисунок 3).
Рисунок 3 – Ввод команды на очистку списка
И если пользователь действительно уверен в своих действиях, необходимо принять предложение программы, после чего произойдет удаление всего списка (см. рисунок 4).
Рисунок 4 – Пустой список
Метод Remove - удаление определенного элемента списка.
Менее радикальный метод, чем предыдущий. Удаляется лишь один, указанный в качестве параметра, элемент списка. Происходит это следующим образом: программа сначала проверяет корректность введенного параметра, если номер удаляемого элемента меньше единицы или больше общего числа элементов списка, то она выводит сообщение об ошибке, если же претензий к введенному параметру у программы нет, то переносятся необходимые ссылки элементов, находящихся рядом с удаляемым, так чтобы список остался связанным, после чего происходит удаление требуемого элемента.
void cList::Remove(int del)
cElement *cur = head, *de;
if ((del>=1) && (del
head = head->getref();
while (j!=del-1)
cur = cur->getref();
de=cur->getref();
cur->setref(de->getref());
coutsystem ("pause");
Для запуска данного метода, в меню работы со списком необходимо ввести команду "delete". Затем ввести номер удаляемого элемента или же команду "back" для отмены удаления (см. рисунок 5).
Рисунок 5 – процесс удаления элемента списка
Список после удаления четвертого элемента будет выглядеть следующим образом (см. рисунок 6).
Рисунок 6 – Список после удаления одного элемента
Метод Insert - вставка нового элемента в указанное место в списке.
В качестве параметров данный метод принимает: позицию добавляемого элемента и его числовое значение. Новый элемент встанет именно на указанное место, таким образом, элементы находящие справа от текущего будут сдвинуты на одну позицию. При добавлении нового элемента в начало списка необходимо просто перенести ссылку с данного элемента на следующий, связав тем самым список и указать ссылку на начальный элемент. Несколько другая ситуация возникает при добавлении нового элемента между двумя уже существующими, для этого с помощью цикла дойти до места вставки элемента, затем связать с новым элементом компоненты, находящиеся справа и слева от него. Ведь что, к примеру, нужно сделать, если необходимо удлинить цепь: необходимо разомкнуть ее, затем прикрепив новое звено к первой части цепи, прицепить к этому же звену вторую, нечто подобное реализуется в данном методе. Стоит отметить, что при указании неверной позиции для добавления, которая меньше единицы или больше общего числа элементов, программа выдаст соответствующие сообщение об ошибке.
void cList::Insert (int pos, int val)
cElement *cur = head;
cElement *temp = new cElement;
temp->setdata(val);
if ((pos>=1) && (pos
temp->setref(head);
while (j!=pos-1)
cur = cur->getref();
p=cur->getref();
cur->setref(temp);
temp->setref(p);
coutsystem ("pause");
Для запуска данного метода, в меню работы со списком необходимо ввести команду "insert". Затем ввести позицию и числовое значение добавляемого элемента или же команду "back" для отмены удаления (см. рисунок 7).
Рисунок 7 - Процесс вставки элемента
Список после добавления в третью позицию элемента со значением 111, список будет выглядеть следующим образом (см. рисунок 8).
Рисунок 8 – Список после добавления элемента
В процессе описания не раз упоминалось меню работы со списком, остается отметить, что данное меню значительно облегчает работу со списком. Алгоритм его работы заключается в циклическом вызове одних и тех же методов, печати списка например, пока не будет введена определённая команда. Список доступных команд можно увидеть, введя "help" в консоли (см. рисунок 9)
Рисунок 9 – Доступные команды
Полностью программный код меню представлен в приложении А.
Тестирование
Часто в процессе работы возникают ситуации, связанные с некорректным вводом данных, что может вызвать выход из строя программы. Разумеется, в каждой программе должны быть реализованы алгоритмы защиты от неопытного пользователя, предостерегающие программу от сбоя. Рассмотрим, каким образом функционируют такие алгоритмы в созданной программе.
Первоначальный ввод списка реализуется представленным ниже кодом:
if (atoi(ss)!=NULL)
mylist.Add(atoi(ss));
Перед вызовом метода add для добавления нового элемента в список, осуществляется проверка введенной строки. Функция atoi переводит строковое значение в числовое и возвращает NULL в случае, если введенная строка не является числом. Таким образом, при вводе будут игнорироваться любые строки не являющиеся числами, кроме строки с командой остановки ввода (см. рисунок 10).
Рисунок 10 – Ввод некорректных данных
После ввода таких данных, список будет выглядеть следующим образом (см. рисунок 11).
Рисунок 11 – Полученный список
Программа продолжает корректно работать после, даже после ввода ошибочных данных. Аналогичные методы борьбы с некорректными данными используются, при остальных операциях ввода, присутствующих в программе.
Заключение
В данной работе были получены понятия об абстрактные типах данных, о принципах их представления в современных языках программирования, в С++ в частности. В большинстве современных императивных языков основной концепцией, используемой для описания абстракций в программном коде, является объектно-ориентированный подход. Объектно-ориентированное программирование (ООП) также, как и подход к программированию на основе АТД, является, в некоторой степени, развитием идей о модульном программировании. Модули – это компоненты программы, которые имеют два важных свойства:
Модули скрывают в себе детали реализации.
Модули могут быть повторно использованы в различных частях программы.
Дэвид Парнас в своей работе 1972 года, представлял модули как абстрактные машины, хранящие внутри себя состояния и позволяющие изменять это состояние посредством определенного набора операций. Эта концепция является базовой, как для концепции абстрактных типов данных, так и для объектно-ориентированного программирования. Проведя параллели между работой Парнаса и современных понятиях ООП, нетрудно заметить взаимосвязь понятий класс и модуль.
В данной работе, линейные односвязные списки, являющие собой абстрактный тип данных, представлены разработанными модулями, для доступа к состояниям которых также реализованы специальные операции, называемые методами в объектно-ориентированном программировании.
Список литературы
1. Иан Грэхем Объектно-ориентированные методы. Принципы и практика = Object-Oriented Methods: Principles & Practice. - 3-е изд. - М.: «Вильямс», 2004. - С. 880.
2. Антони Синтес Освой самостоятельно объектно-ориентированное программирование за 21 день = Sams Teach Yourself Object-Oriented Programming in 21 Days. - М.: «Вильямс», 2002. - С. 672.
3. Бертран Мейер Объектно-ориентированное конструирование программных систем + CD . Интернет-университет информационных технологий - ИНТУИТ.ру, Русская Редакция, 2005
4. Биллиг В.А. Основы программирования на C# . Интернет-университет информационных технологий - ИНТУИТ.ру, 2006
5. “Новые языки программирования и тенденции их развития”, Ушкова В., 2005 г.
6. Бьерн Страуструп "Язык программирования C++" Специальное издание либо 3-е издание изд. Бином, Невский Диалект, ISBN 5-7989-0226-2, 5-7940-0064-3, 0-201-70073-5
7. Бьерн Страуструп "Дизайн и эволюция языка C++". ДМК-Пресс, Питер, ISBN 5-469-01217-4, 0-201-54330-3
8. Бьярне Страуструп "Программирование принципы и практика использования C++". "И.Д. Вильямс", 2011, ISBN 978-5-8459-1621-1 (рус.)
9. Гради Буч и др. "Объектно-ориентированный анализ и проектирование с примерами приложений" 2-е либо 3-е издание. Бином, Невский диалект, Вильямс ISBN 978-5-8459-1401-9, 0-201-89551-X, 0-8053-5340-2, 5-7989-0067-3, 5-7940-0017-1
10. Скотт Мейерс "Эффективное использование C++. 50 рекомендаций по улучшению ваших программ и проектов" ДМК, Питер, ISBN 0-201-92488-9, 5-93700-006-4, 5-469-01213-1
Приложение A
Программный код меню
#include "cList.h"
#include "string.h"
using namespace std;
coutwhile (strstr(ss,"stop")==NULL)
if (atoi(ss)!=NULL)
mylist.Add(atoi(ss));
system ("cls");
while (strstr(com,"exit")==NULL)
coutmylist.Print();
if (strstr(com,"help")!=NULL) com_ind=1;
if (strstr(com,"add")!=NULL) com_ind=2;
if (strstr(com,"insert")!=NULL) com_ind=3;
if (strstr(com,"delete")!=NULL) com_ind=4;
if (strstr(com,"dellist")!=NULL) com_ind=5;
switch (com_ind)
system ("cls");
system ("cls");
coutcoutcoutcoutcoutcoutcoutcom_ind=0;
if (strstr(ss,"back")==NULL)
if (atoi(ss)!=NULL)
mylist.Add(atoi(ss));
system ("cls");
//insert elements
if (strstr(ss,"back")==NULL)
if (atoi(ss)!=NULL)
system ("cls");
if (strstr(ss,"back")==NULL)
if (atoi(ss)!=NULL)
mylist.Insert(pos,atoi(ss));
system ("cls");
//delete elements
if (strstr(ss,"back")==NULL) определяется множеством значений данного и набором операций... связных структур данных – списков . Структура данных – это совокупность элементов данных , между которыми... в памяти ЭВМ называется абстрактной или логической. Чаще...
Множественный тип данных . Множества
Лекция >> Информатика, программирование... тип похожим на простые типы данных . Множественные типы описываются в разделе типов ... ВУ может быть описано. Абстрактные вычислительные структуры, описывающие ввод... других случаях типы всех компонент списка должны совпадать с типом компоненты файла. ...
Объектно-ориентированные базы данных , работающие в распределенных сетях
Реферат >> ИнформатикаРазвивающимися направлениями языков программирования с абстрактными типами данных и объектно-ориентированных языков программирования. ... типов данных - список и массив. Каждый литерал уникально идентифицируется индексом в массиве и порядковым номером в списке ...
Абстрактные модели защиты информации
Реферат >> ИнформатикаЗащиты информации………………………………………………..17 Абстрактные модели защиты информации... регулирующих взаимодействие с обоими типами данных (Certification Rules): Все... различные вариации и дополнения к имеющемуся списку . Уровни безопасности – определенное...
Все встроенные типы данных, являются абстрактными, хотя так их называют редко.
Понятие абстракции
Абстракция - это суждение или представление о некотором объекте, которое содержит только свойства, являющиеся существенными в данном контексте. Абстракция позволяет объединять экземпляры объектов в группы, внутри которых общие свойства объектов можно не рассматривать, т.е. абстрагироваться от них. Абстракция - это эффективное средство против сложности программирования, позволяющее программисту сосредоточиться на существенных свойствах объектов. Виды абстракций: абстракция процесса и абстракция данных .
Абстракция процесса. Все подпрограммы являются абстракциями процессов, они определяют способ, с помощью которого программа устанавливает, что необходимо выполнить некоторый процесс, без уточнения деталей того, как именно это следует сделать. Возможность абстрагироваться от многочисленных деталей алгоритма, который выполняется подпрограммой, позволяет создавать, читать и понимать большие программы. Любой абстракции данных являются операции, определяемые как абстракции процессов.
Абстракция данных. Абстрактный тип данных - это инкапсуляция, которая содержит только представления данных одного конкретного типа и подпрограммы, которые выполняют операции с данными этого типа. С помощью управления доступом несущественные детали описания типа можно скрыть от внешних модулей, которые используют такой тип. Программные модули, которые используют абстрактный тип данных, могут объявлять переменные этого типа, даже несмотря на то, что реальное представление типа скрыто от них. Экземпляр абстрактного типа данных называется объектом.
Причина создания абстракции типа данных и абстракции процесса - это средство против сложности, способ сделать большие и/или сложные программы более управляемыми.
Инкапсуляция
Разделение программы на синтаксические контейнеры, которые содержат группы логически связанных подпрограмм и данных. Эти синтаксические контейнеры называются модулями, а процесс их разработки- модуляризацией.
Составление программы из наборов подпрограмм и данных, каждый из которых можно компилировать отдельно, без повторной компиляции остальной части программы. Такой набор называется единицей компиляции.
Инкапсуляция - это способ объединения в единое целое подпрограмм и данных, которые они обрабатывают. Инкапсуляция, которая компилируется либо отдельно, либо независимо от других, является основой абстрактной системы и логической организации набора соответствующих вычислений.
Абстрактные типы данных, определяемые пользователем
Абстрактные типы данных, определяемые пользователем, должны иметь следующие свойства:
1) определение типа, позволяющее программным модулям объявлять переменные этого типа, создавая при этом реальное представление этих переменных в памяти.
2) набор операций для манипуляций с объектами данного типа.
Формальное определение абстрактного типа данных в контексте типов, определенных пользователем: абстрактный тип данных - это тип данных, который удовлетворяет следующим двум условиям.
Представление (определение типа) и операции над объектами данного типа содержатся в одной синтаксической единице, переменные данного типа можно создавать и в других модулях.
Представление объектов данного типа скрыто от программных модулей, использующих этот тип, над объектами можно производить операции, которые прямо предусмотрены в определении типа.
Упаковка представления типа и операций в отдельную синтаксическую единицу, позволяет организовывать программу в виде логических единиц, которые можно компилировать отдельно. Во-вторых, появляется возможность модифицировать представления объектов данного типа или операции с ними в отдельной части программы. У сокрытия деталей представления типа есть преимущества. Клиенты не могут "видеть" детали представления объектов, и их код не зависит от этого представления. Таким образом, представления объектов можно изменять в любое время, не требуя при этом вносить изменения в код клиентов. Другим очевидным и важным преимуществом сокрытия информации является повышенная надежность. Клиенты не могут непосредственно изменять основные представления объектов ни преднамеренно, ни случайно, следовательно, возрастает целостность таких объектов. Объекты можно изменять только с помощью предусмотренных для этого операций.
Вопросы разработки типов
Должна существовать возможность делать имя типа и заголовки подпрограмм видимыми в клиентах абстракции. Это позволяет клиентам объявлять переменные абстрактного типа и манипулировать их значениями. Несмотря на то что имя типа должно быть видимым извне, его определение должно быть скрыто.
Существует очень мало общих встроенных операций, которые можно выполнять с объектами абстрактных типов, в отличие от операций, предусмотренных определением типа. К таким операциям относятся присваивания, а также проверки равенства и неравенства. Если язык не позволяет пользователям перегружать операцию присваивания, то она должна быть встроенной. Проверки равенства и неравенства в одних случаях должны быть заранее определены, а в других - нет. Разработчик типа должен определить операции для большинства абстрактных типов данных сам.
Языки Smalltalk, C++ и Java непосредственно поддерживают абстрактные типы данных.
Абстрактные типы данных в языке C++
Языки Ada и Modula-2 обеспечивают инкапсуляцию, которая может использоваться при моделировании абстрактных типов данных, в языке C++ введено понятие класса, который непосредственно поддерживает абстрактные типы данных. В языке C++ классы - это типы, а пакеты языка Ada и модули языка Modula-2 типами не являются. Пакеты и модули импортируются, позволяя импортирующей программной единице объявлять переменные любого типа, определенного в пакете или модуле. В программе на языке C++ переменные объявляются как сущности, имеющие тип данного класса. Таким образом, классы гораздо больше похожи на встроенные типы, чем пакеты или модули. Программная единица, которая видит пакет в языке Ada или модуль в языке Modula-2, имеет доступ к любым открытым сущностям просто по их именам. Программная единица на языке C++, которая объявляет экземпляр класса, также имеет доступ к любым открытым сущностям в этом классе, но только через экземпляр этого класса.
