extracted_text:
тема 2 вопрос 6
основные показатели оценки качества программ
Качество программ  это определенная совокупность свойств программного продукта,
обеспечивающих решение возложенных на него задач в заданной среде функционирования и с
допустимым множеством исходных данных.
Показателями качества являются надежность (безошибочность, включая и экстремальные,
нестандартные условия выполнения), модифицируемость (легкость доработки и разбиения на модули),
мобильность (настройка на новые условия, перенос на другую ЭВМ с минимальными затратами),
дружественность интерфейса между ЭВМ и пользователем, занимаемый объем памяти, качество
документации, подробность документирования самой программы.
Надежность программы является наиболее важным критерием качества программы в целом.
Модифицируемость программы  функциональное разбиение программы на автономные модули
(модульное программирование), возможность доработки (изменения) содержания модулей.
Переносимость  легкость адаптации к изменению среды, т.е. компонентов программирования,
возможность переноса программы из одной операционной системы в другую.
Занимаемая память  объем ОЗУ (кбайт, Мбайт) и объем ВЗУ, необходимых для функционирования
программы.
Надежность программы определяется надежностью ее составляющих:
 алгоритмическая (вычислительная) надежность:
 информационная надежность:
 надежность программного обеспечения;
 надежность аппаратная.
Рассмотрим кратко отдельные составляющие надежности программ.
Алгоритмическая (вычислительная) надежность  способность программы выполнять свои функции
при изменении условий функционирования.
Информационная надежность предусматривает:
 способность алгоритма или программы правильно выполнять свои функции при различных ошибках в
исходных данных;
 способность информационной системы обеспечивать целостность хранящихся в ней данных;
 способность алгоритма и программы нормально функционировать в случае неправильных действий
пользователя при вводе информации.
Надежность программного обеспечения  это характеристика способности программного
обеспечения выполнять возложенные на него функции при поступлении требований на их выполнение,
показатель качества, характеризующий свойства программного изделия выдавать одни и те же
результаты при различных условиях функционирования.
При рассмотрении вопроса надежности программ следует учитывать тот факт, что надежность и
правильность программ  не одно и то же. Правильность программы  это отсутствие в программе,
разработанной по заданному алгоритму, программных ошибок. Надежность программы  более широкое
понятие.
Надежность  это способность программ давать разумные результаты при всех возможных данных и
действиях, в частности, в аномальных условиях. Если в программу вводят необычные данные, они
должны быть выявлены и отброшены. Должны выявляться ошибки программы, ошибки данных, к
которым следует добавить проблему предельных случаев и возможные ошибки аппаратуры.
Рассмотрение всех составляющих качества программ является очень сложной и объемной задачей.
Поэтому мы ограничимся только теми показателями качества программ, которые зависят от
разработчика (программиста).
72. Основные понятия метода проектирования БД, сущность – связь. Примеры.
Модель «сущностьсвязь» (англ. “EntityRelationship model”), или ERмодель, предложенная П. Ченом в
1976 г., является наиболее известным представителем класса семантических (концептуальных,
инфологических) моделей предметной области. ERмодель обычно представляется в графической
форме, с использованием оригинальной нотации П. Чена, называемой ERдиаграмма, либо с
использованием других графических нотаций (Crow's Foot, Information Engineering и др.). Основные преимущества ERмоделей:
наглядность;
модели позволяют проектировать базы данных с большим количеством объектов и атрибутов;
ERмодели реализованы во многих системах автоматизированного проектирования баз данных
(например, ERWin).
Основные элементы ERмоделей:
объекты (сущности);
атрибуты объектов;
связи между объектами.
Модель “сущность  связь” (МСС) (entity  relation diagram  ERD) является неформальной моделью
предметной области (ПО) и используется на этапе инфологического проектирования БД.
Моделируются объекты ПО и их взаимоотношения.
Основное назначение МСС  семантическое описание ПО и представление информации для
обоснования выбора видов моделей и структур данных, которые в дальнейшем будут использованы в
информационной системе.
Для построения МСС используются три основных конструктивных элемента для представления
составляющих ПО  сущность, атрибут и связь. Информация о проекте представляется с
использованием графических диаграмм.
“Время” в составе конструктивных элементов отсутствует, но может быть представлено в модели
посредством атрибутов (напр.: ГОДРОЖДЕНИЯПОЛУЧЕНОВИЮНЕ,...).
Сущность  собирательное понятие, некоторая абстракция реально существующего объекта, процесса
или явления, о котором необходимо хранить информацию в системе.
Примеры сущностей:
материальные:
предприятие;
изделие;
сотрудники;
нематериальные:
рефераты научных статей;
описание явления;
описание структур данных;
В моделях МСС каждая рассматриваемая сущность является основным местом сбора информации об
этой сущности.
“Тип сущности” определяет множество однородных объектов, а “экземпляр сущности”  конкретный
объект из множества.
Каждая сущность должна иметь имя. Например, сущность "СТУДЕНТ".
“Атрибут” (А)  поименованнная характеристика сущности. При помощи атрибутов моделируются
свойства сущностей: (сущность: КНИГА, атрибуты: НАЗВАНИЕ, АВТОР, ГОДИЗДАНИЯ).
Основная роль атрибутов  описание свойств сущности. Другая роль  идентификация экземпляра
сущности. То есть каждый экземпляр сущности должен иметь уникальное имя. В качестве имени
выступает один или несколько атрибутов. Например, "НОМЕР ЗАЧЕТНОЙ КНИЖКИ" или "НОМЕР"
и "СЕРИЯ ПАСПОРТА".
“Связь”  средство представления отношений между сущностями в модели ПО. Тип связи
рассматривается между типами сущностей, например, между сущностями СТУДЕНТ и ГРУППА может
быть связь УЧИТЬСЯ. То есть введение связи между двумя сущностями отражает семантику
некоторого предложения. В данном случае, это СТУДЕНТ УЧИТСЯ В ГРУППЕ. Конкретный
экземпляр связи данного типа существует между конкретными экземплярами данных типов сущностей.
Например, ИВАНОВ УЧИТСЯ КМ31.
В модели "сущностьсвязь" поддерживаются бинарные связи. В общем случае в ПО могут быть n
арные связи между сущностями.

Основные понятия эффективности функционирования КС Наиболее общей, интегральной характеристикой любой сложной, тем более человекомашинной,
системы является эффективность ее функционирования, т.е. способность системы достигать
поставленную цель в заданных условиях применения и с определенным качеством. Иначе говоря, это
комплексное операционное свойство целенаправленного процесса функционирования системы,
характеризующее приспособленность этого процесса к достижению цели реализуемой системой
операции.
Под системой понимается совокупность взаимосвязанных эргатических и неэргатических элементов
(аппаратных, программных, информационных средств, обслуживающего персонала, пользователей),
непосредственно участвующих в процессе выполнения операции. Операция – это упорядоченная
совокупность взаимосвязанных действий, направленных на достижение заданной цели. Цель – это
желаемый результат функционирования системы, достижимый в течение определенного времени.
В теории эффективности различают объект и предмет исследования. Объектом исследования
является операция, т.е. процесс применения (функционирования) системы. Применительно к КС под
операцией понимается упорядоченная совокупность взаимосвязанных действий эргатических и
неэргатических элементов сети, направленных на удовлетворение запросов пользователей. Предмет
исследования – это закономерности оптимальной организации процесса функционирования системы, а
применительно к компьютерной сети – закономерности оптимальной (или рациональной) организации
процессов удовлетворения запросов пользователей. Следует различать понятия «эффективность» и
«качество». Если эффективность относится к операции, к процессу функционирования системы, то
качество – непосредственно к самой системе. Качество системы – это совокупность ее свойств,
обусловливающих пригодность системы удовлетворять определенные потребности в соответствии с ее
назначением. Под свойством системы понимается ее объективная особенность, проявляемая при
создании и эксплуатации (использовании) системы. Понятие эффективности функционирования
системы является более широким, чем понятие качества системы. Эффективность зависит от качества,
но не наоборот. Оценивание эффективности связано не только со свойствами системы, но и со
свойствами результата ее функционирования и ресурсов, затрачиваемых на достижение этого
результата, т.е. с оцениванием объектов, не включаемых в систему. Иначе говоря, эффективность
функционирования системы определяется не только ее свойствами, но и способами и условиями
применения системы.
Оценка эффективности предусматривает совместный анализ эффекта и затрат на его достижение.
Такая оценка рассматривается в тесной связи с целями, которые достигаются (или должны быть
достигнуты) при использовании системы (в нашем случае компьютерной сети). Она напрямую
согласуется с задачами производственнохозяйственной или любой другой деятельности организации,
использующей сеть в качестве технической базы по решению всех задач.
Для краткости вместо длинного термина «эффективность процессов функционирования системы»
иногда употребляют более короткий термин «эффективность системы», имея в виду при этом ту же
трактовку.
Оценка эффективности функционирования компьютерных сетей базируется на основополагающих,
методологических предпосылках. Главные из них заключаются в следующем.
1. Компьютерная сеть принадлежит к классу человекомашинных систем (ЧМС). Это относится и к
отдельным функциональным частям сети (подсистемам). Следовательно, при исследовании
эффективности КС, независимо от ее принадлежности к тому или иному типу ЧМС, необходимо
учитывать параметры и характеристики всех трех компонентов: человека (обслуживающего и
управленческого персонала сети и пользователей), машины (программноаппаратных и
информационных средств сети) и производственной среды.
2. Компьютерная сеть – сложная многофункциональная человекомашинная система, процесс
функционирования которой определяется многими показателями, параметрами и факторами. В связи с
этим проводить оценку эффективности такой системы как единого целого не всегда целесообразно и
нередко трудно осуществимо. Оценку можно выполнять сначала отдельно для крупных
функциональных частей сети, а затем полученные дифференциальные оценки использовать для
формирования интегральных оценок всей сети.
3. Эффективность КС должна оцениваться с учетом влияния на процессы функционирования сети всех
факторов.
Факторы, определяющие эффективность функционирования сети, можно разбить на такие группы: а) свойства самой сети:
 общие: готовность, надежность, живучесть, ремонтопригодность;
 индивидуальные: структура сети, функциональные возможности сети в целом и ее эргатических и
неэргатических элементов;
б) свойства привлекаемых ресурсов:
 количество ресурсов каждого типа;
 качество привлекаемых ресурсов;
в) свойства условий функционирования сети:
 неуправляемые (природные условия, воздействие источников помех, интенсивность неуправляемых
потоков запросов пользователей и др.);
 управляемые (организация функционирования, реализуемые способы доступа к передающей среде и
управления обменом данных и др.).
4. При исследовании эффективности КС ее целесообразно рассматривать как интегральное свойство,
определяющее:
 степень соответствия сети своему назначению – целевая эффективность;
 техническое совершенство сети (техническая эффективность);
 экономическую целесообразность – экономическую эффективность.
Для количественной оценки целевой, технической и экономической эффективности необходимо иметь
три набора (системы) показателей эффективности: показатели целевой эффективности (ПЦЭ)
функционирования КС, показатели технической эффективности (ПТЭ) и показатели экономической
эффективности (ПЭЭ).
Отсюда возникает проблема множественности показателей эффективности, суть которой заключается в
том, что по мере увеличения количества привлекаемых к оценке показателей повышаются
комплексность, глубина и полнота оценки, определенность представления о возможностях сети, но
вместе с тем усложняется сам процесс оценки, для его реализации увеличивается время и другие
ресурсы (материальные и трудовые). Следовательно, необходимо искать компромиссное решение.
5. В рамках комплексного исследования эффективности КС (подсетей, систем, узлов и звеньев) должна
предусматриваться оценка эффективности внедрения новой техники (новых аппаратных, программных
и информационных средств) и технологий с целью совершенствования эксплуатируемой сети.
Новая техника и технологии (НТТ), внедряемые в КС, могут быть разделены на три группы:
 НТТ1 – новая техника и технологии, непосредственно участвующие в процессе производства
продукции, т.е. в процессе удовлетворения запросов пользователей. К ним относятся: новые
аппаратные и программные средства, непосредственно участвующие в передаче и обработке
информации по запросам пользователей; новые информационные средства, используемые для
удовлетворения этих запросов; новые сетевые технологии, так же непосредственно используемые в
процессе производства продукции сетей;
 НТТ2 – новая техника и новые информационные и телекоммуникационные технологии, используемые
для управления производственнохозяйственной и другой деятельностью организации, в интересах
которой функционирует компьютерная сеть. К ним относятся новые средства и технологии
информатизации этой организации и автоматизации ее работы. Непосредственно в производстве
продукции они не участвуют;
 НТТ3 – новые средства и технологии, входящие в состав эргономического обеспечения КС и
предназначенные для повышения эффективности трудовой деятельности операторов (администраторов,
пользователей) человекомашинных систем, функционирующих в составе КС.
Принадлежность внедряемых средств и технологий к одной из указанных групп определяется их
назначением. Например, на таком предприятии, как центр обработки информации (ЦОИ) сети,
компьютер может входить в первую группу, если он непосредственно участвует в решении задач по
запросам пользователей, или во вторую группу, если он включен в состав АСУ ЦОИ, или, наконец, в
третью группу, если он используется как средство повышения эргономичности одной из ЧМС ЦОИ. В
связи с этим для полноты исследований необходимо рассматривать эффективность внедрения всех
трех групп НТТ.
Необходимость и целесообразность деления НТТ на три группы объясняется следующими факторами:
 принципиальным различием техники и технологии указанных групп по своему непосредственному
целевому назначению (хотя конечная цель их использования одна и та же – повышение объема и качества выпускаемой продукции сети, т.е. повышение эффективности функционирования сети,
увеличение количества и качества предоставляемых услуг, повышение интеллектуального уровня
услуг), что, в свою очередь, отражается на методологии оценки эффективности их применения и
особенно на требованиях по эффективности;
 наличием специфики при формировании методологических и методических основ оценки
эффективности использования НТТ различных групп.
Следовательно, правомерным и целесообразным является такой подход, когда методология оценки
эффективности внедрения НТТ включает методологические аспекты, специфические для оценки
эффективности внедрения НТТ различных групп.
6. Ввиду специфичности оценки эффективности средств и технологий, составляющих систему
эргономического обеспечения разработки и эксплуатации (СЭОРЭ) компьютерной сети (или ее
функциональных частей), такую оценку целесообразно проводить автономно. Эргономическое
обеспечение (ЭО) оказывает существенное влияние на выходные техникоэксплуатационные и технико
экономические характеристики сети, а также на качество производимой сетью продукции с учетом ее
специфического характера (это результаты удовлетворения запросов пользователей сети). Требования
по качеству продукции сети во многом определяются ее видом. На первый план могут быть поставлены
своевременность, достоверность, объем предоставляемой информации и др. Расходы на формирование
и функционирование СЭОРЭ сети, связанные с обеспечением требуемого качества продукции, должны
иметь обоснованные ограничения, так как по мере роста требований по качеству эти расходы
увеличиваются форсированно.
7. Полнота и глубина оценки эффективности функционирования КС или оценки эффективности
внедрения НТТ с целью совершенствования эксплуатируемой сети достигаются в большей степени,
если к оценке привлекаются:
 интегральные показатели (для интегральной, суммарной оценки) и частные (для оценки частного
эффекта, получаемого при функционировании КС или внедрении НТТ);
 показатели для оценки прямого экономического эффекта, имеющего непосредственное стоимостное
выражение, и косвенного эффекта, оцениваемого с помощью временных, точностных, надежностных и
других единиц измерения.
Система показателей оценки эффективности функционирования КС и внедрения НТТ и алгоритмы
определения их значений должны обеспечивать возможность проведения как априорной, так и
апостериорной оценки.

file_name: тема 2 вопрос 6.docx

intro:
Занимаемая память - объем ОЗУ (кбайт, Мбайт) и объем ВЗУ, необходимых для функционирования программы.
Надежность программы определяется надежностью ее составляющих:
- алгоритмическая (вычислительная) надежность:
- информационная надежность:
- надежность программного обеспечения;
- надежность аппаратная.
Рассмотрим кратко отдельные составляющие надежности программ.
Алгоритмическая (вычислительная) надежность - способность программы выполнять свои функции при изменении условий функционирования.

title: Лекция "Основные показатели оценки качества программ"


extracted_text:
тема 2 вопрос 11
язык турбо паскаль структурированные типы данных. примеры
Структурированные типы данных
Структурированные типы данных определяют наборы однотипных или разнотипных
компонент. Типы компонент образуются из других типов (простых, структурированных,
указателей и т. д.) данных.
В языке Паскаль существуют следующие структурированные типы.




типмассив;
типзапись;
типмножество;
типфайл.
В Turbo Pascal имеется еще два структурированных типа  типстрока string и типстрока
PChar, являющиеся разновидностями массива.
В дальнейшем объекты структурированных типов для краткости будут называться теми же
именами, что и их типы, без указания слова "тип": массив, запись, множество, файл, строка.
В стандарте языка существуют упакованные (packed) и неупакованные структурированные
типы. В Turbo Pascal слово packed, характеризующее упакованный тип, не оказывает
никакого влияния; в случае, когда это возможно, упаковку данных осуществляется
автоматически.
6.1. Массив
Типмассив представляет собой фиксированное количество упорядоченных однотипных
компонент, снабженных индексами. Он может быть, одномерным и многомерным. Чтобы
задать типмассив, используется зарезервированное слово array, после которого следует
указать тип индекса (индексов) компонент (в квадратных скобках) и далее после слова of
тип самих компонент.
type
   <имя типа> = аггау[<тип индекса(индексов)>] of <тип компонент>;
Пример.
type
   Arr = array[1..3] of Real;
   {типмассив из 3 вещественных чисел}
   Matrix = array[1..3, 1..2] of Integer;
   {тип  двумерный массив целых чисел, состоящий из 3 строк и 2 столбцов}
Введя типмассив, можно затем задать переменные или типизированные константы этого
типа.
Размерность массива может быть любой, компоненты массива могут быть любого, в том
числе и структурированного, типа, индекс (индексы) может быть любого порядкового типа,
кроме типа Longint.
При задании значений константемассиву компоненты указываются в круглых скобках и
разделяются запятыми, причем, если массив многомерный, внешние круглые скобки
соответствуют левому индексу, вложенные в них круглые скобки  следующему индексу и
т. д.
Так, для введенных выше типов можно задать, например, следующие переменные и
константы:
var
   M1, M2: Arr;
   Matr: Matrix;
const М3: Arr = (1 , 2, 3) ;
   Mat: Matrix = ((1, 2), (3, 4), (5, 6));
Последняя константа соответствует следующей структуре:
1
3
5
2
4
6
Примечание. Типмассив можно вводить непосредственно и при определении
соответствующих переменных или типизированных констант. Например:
var
   Ml, M2: array[1..3] of Real;
   Matr: array[1..3, 1..2] of Integer;
Здесь определены те же массивы, что и в предыдущем примере.
При таком объявлении массивов следует помнить, что их типы не будут идентичными
никаким другим типам, даже если они имеют одинаковую структуру. Поэтому передавать
их как параметры в подпрограмму нельзя (см. п. 10.3), нельзя также присваивать им
значения других массивов (и наоборот), даже если их структуры совпадают.
Доступ к компонентам массива осуществляется указанием имени массива, за которым в
квадратных скобках помещается значение индекса (индексов) компоненты. В общем случае
каждый индекс компоненты может быть задан выражением соответствующего типа,
например:
М1[2] ,
Matr[X, Y],
M2[Succ(I) ] и т. д.
Одному массиву можно присвоить значение другого массива, но только идентичного типа.
Так, если заданы следующие массивы:
var А, В: array[1..5] of Integer;
    С: array[1..5] of Integer;
то допустим следующий оператор:
A := В;
С другой стороны, оператор
С := А;
недопустим, т. к. массивы А и С  не идентичных типов.
Имеются некоторые отличия в.работе с одномерными массивами символов (не путать с
величинами типа string  см. п. 6.2). Так, типизированным константам этого вида можно
присвоить значение как обычным строковым константам, указав строку символов в
апострофах, например
const
   A: array[1..5] of Char='aaaaa';
   В: array[1..3] of Char='bbb';
Для таких массивов, как и для строк, можно использовать операции сравнения (даже если
они не идентичных типов и даже если имеют различный размер) и конкатенации
(объединения)  см. п. 6.2. Их можно использовать в операторах вывода Write и WriteLn.
Например, для введенных выше массивов можно написать
if A > В then
   WriteLn(A)
else
   WriteLn(B);
Глава 6. СТРУКТУРИРОВАННЫЕ ТИПЫ ДАННЫХ Структурированные типы данных определяют наборы однотипных или разнотипных
компонент.
Типы компонент образуются из других типов (простых, структурированных, указателей и
т. д.)
данных. В языке Паскаль существуют следующие структурированные типы:
  типмассив;
  типзапись;
  типмножество;
  типфайл.
В Turbo Pascal имеется еще два структурированных типа:
  типстрока string и
  типстрока PChar, являющиеся разновидностями массива.
В дальнейшем объекты структурированных типов для краткости будут называться теми же
именами, что и их типы, без указания слова "тип": массив, запись, множество, файл, строка.
В стандарте языка существуют упакованные (packed) и неупакованные структурированные
типы. В Turbo Pascal слово packed, характеризующее упакованный тип, не оказывает
никакого
влияния; в случае, когда это возможно, упаковка данных осуществляется автоматически.
6.1. Массив
Типмассив представляет собой фиксированное количество упорядоченных однотипных
компонент, снабженных индексами. Он может быть одномерным и многомерным. Чтобы
задать
типмассив, используется зарезервированное слово array, после которого следует указать
тип
индекса (индексов) компонент (в квадратных скобках) и далее после слова of  тип самих
компонент:
type
<имя типа> = array[<тип индекса(индексов)>] of <тип компонент>;
Пример.
type
Arr = array[1..3] of Real;               {тип—массив из 3 вещественных чисел}
Matrix =  array[1..3, 1..2] of Integer;  {тип  двумерный массив целых чисел, состоящий
из 3 строк и 2 столбцов}
Введя типмассив, можно затем задать переменные или типизированные константы этого
типа.
Размерность массива может быть любой, компоненты массива могут быть любого, в том
числе
и структурированного, типа, индекс (индексы) может быть любого порядкового типа,
кроме типа Longint.
При задании значений константемассиву компоненты указываются в круглых скобках и
разделяются запятыми, причем, если массив многомерный, внешние круглые скобки
соответствуют левому индексу, вложенные в них круглые скобки  следующему индексу
и т. д.
Так, для введенных выше типов можно задать, например, следующие переменные и
константы:
var
Ml, М2: Arr;
Matr: Matrix;
const
M3: Arr =(1, 2, 3);
Mat: Matrix = ((1, 2), (3, 4), (5, 6)); Последняя константа соответствует следующей структуре:
1 2
3 4
5 6
Примечание.
  Типмассив можно вводить непосредственно и при определении соответствующих
переменных
или типизированных констант.
Например:
var
Ml, M2: array [1..3] of Real;
Matr: array[1..3, 1..2] of Integer;
Здесь определены те же массивы, что и в предыдущем примере.
При таком объявлении массивов следует помнить, что их типы не будут идентичными
никаким
другим типам, даже если они имеют одинаковую структуру. Поэтому передавать их как
параметры в подпрограмму нельзя (см. п. 10.3), нельзя также присваивать им значения
других массивов (и наоборот), даже если их структуры совпадают.
Доступ к компонентам массива осуществляется указанием имени массива, за которым в
квадратных скобках помещается значение индекса (индексов) компоненты. В общем случае
каждый индекс компоненты может быть задан выражением соответствующего типа,
например:
M1[2], Matrix[X, Y], M2[Succ(I)] и т. д.
Одному  массиву  можно  присвоить значение другого массива, но только идентичного
типа.
Так, если заданы следующие массивы:
var А, В: array[l..5] of  Integer;
С: array [1. .5] of Integer;
то допустим следующий оператор:
A :=  В;
С другой стороны, оператор
С := А;
недопустим, т. к. массивы А и С  не идентичных типов.
Имеются некоторые отличия в работе с одномерными массивами символов (не путать с
величинами типа string  см. п. 6.2). Так, типизированным константам
этого вида можно присвоить значение как обычным строковым константам, указав строку
символов в апострофах, например
const
A: array[1..5] of Char='ааааа';
В: array[1..3] of Char='bbb';
Для таких массивов, как и для строк, можно использовать операции сравнения (даже если они не идентичных типов и даже если имеют различный размер) и конкатенации
(объединения)
 см. п. 6.2. Их можно использовать в операторах вывода Write и WriteLn. Например,
для введенных выше массивов можно написать
if A  >  В then
  WriteLn(A) else
  WriteLn(B);
6.2. Строка типа string
В Turbo Pascal типстрока (стандартный тип string)  последовательность символов
произвольной длины (до 255 символов). Строку можно рассматривать как массив
символов,
однако в связи с широким использованием строк и некоторыми особенностями по
сравнению
со стандартными массивами они выделены в отдельный тип данных.
У типастроки в квадратных скобках может быть указан его размер (от 1 до 255). Если
размер строки не указан, он считается равным 255, например:
var
Str: string[80];
MaxStr: string; {строка в 255 символов}
const
January: string[10] = 'Январь';
Для строк применимы операции конкатенации (+) и сравнения.
Операция конкатенации добавляет к первой строке вторую.
Пример.  Объединение двух строк.
Str, Strl, Str2:string[80];
begin
Strl := 'Turbo ';
Str2 := 'Pascal';
Str := Strl + Str2; {в переменной Str — 'Turbo Pascal'}
end.
Сравнивать можно строки разной длины. Сравнение осуществляется слева направо в
соответствии с ASCIIкодами соответствующих символов. Считается, что отсутствующие
символы в более короткой строке имеют код меньше кода любого действительного
символа.
Например, 'XS' больше, чем 'X'.
Пример.
Проверить, является ли введенная совокупность символов именем месяца на русском
языке.
program EXAMPLE11;
const
Instance: array[l..12] of string!10]=
('ЯНВАРЬ', 'ФЕВРАЛЬ', 'МАРТ', 'АПРЕЛЬ', 'МАЙ', 'ИЮНЬ', 'ИЮЛЬ', 'АВГУСТ',
'СЕНТЯБРЬ',
'ОКТЯБРЬ', 'НОЯБРЬ', 'ДЕКАБРЬ');
Month: Boolean = False;
var Str: string[10]; i: Integer;
begin
Writeln('Введите заглавные символы: ');
ReadLn(Str);
for i := 1 to 12 do
if Str = Instance[i] then
  Month:=True;
if Month then
  WriteLn('Введено имя месяца') else
  WriteLn('Введено не имя месяца')
end.
Фактически строка N символов представляет собой массив из N+1 символа:
string[N]  = аrrау[0..N] of Char.
Нулевой символ предназначен для указания используемого количества символов строки и
может изменяться от символа с кодом 0 до символа с кодом N. С ним можно работать как
и
с остальными символами строки (записывать и читать его значение и т. д.), но не забывая
о его основном предназначении.
6.3. ASCIIZстрока
В версии 7.0 для совместимости с другими языками программирования и средой Windows
введен
еще один вид строк  строки, оканчивающиеся нулевым байтом  символом с кодом 0
(т. н. ASCIIZстроки). В отличие от строк типа string у этих строк не накладывается
ограничение на их размер (фактически размер может быть до 65535 байтов). Этим строкам
дан стандартный тип PChar. Фактически этот тип является указателем на символ (об
указателях
см. п. 7):
PChar = ^Char;
Однако применение расширенного синтаксиса (ключ {Х+}  см. п. 17.7.1) позволяет
использовать такую переменную как строку, эквивалентную масиву типа
pChar = array[0..К] of Char,
где К  количество символов в строке, не считая завершающего символа с кодом 0.
В отличие от типа string символ с индексом 0 здесь является первым символом строки,
а последний символ с индексом К  завершающим символом с кодом 0.
При работе с ASCIIZстроками целесообразно задавать расширенный синтаксис; в этом
случае
не возникают трудности при использовании различных стандартных подпрограмм,
работающих
со строками.
Пример.
Использование строк типа PChar при расширенном синтаксисе.
{не обязательно так как используется по умолчанию}
program EXAMPLE12;
{$Х+}
type
Т = array[0..7] of Char;   {массив для строки из 7 символов}
var
Str: PChar;
const
А: Т = 'привет!'#0; begin
Str := 'ПРИВЕТ!';
WriteLn(Str);
Str := @А;
WriteLn(Str);
WriteLn(Str[1]);{вывод символа 'р'}
ReadLn
end.
{вывод строки: ПРИВЕТ!}
{допустимо также: Str:=A}
{вывод строки: привет!}
Если используется ключ {$Х}, переменная типа PChar в этом случае рассматривается
как указатель на один единственный символ. В этом случае ни один из операторов
предыдущего примера, за исключением операторов Str:=@A; и ReadLn, недопустимы, а
оператор WriteLn(Str^), выполненный после оператора Str:=@A;, выдаст один символ "п".
Для работы с ASCIIZстроками в версии 7.0 используются специальные стандартные
модули
Strings (см. п. 16.2) и WinDos (см. п. 16.6).
6.4. Запись
Типзапись включает ряд компонент, называемых полями, которые могут быть разных
типов.
При задании типазаписи после зарезервированного слова record следует перечислить все
поля типазаписи с указанием через двоеточие их типов и завершить задание типа словом
end. Поля отделяются друг от друга точкой с запятой. Количество полей записи может
быть
любым.
Пример.
type
Complex = record   {Тип комплексных чисел}
Re: Real;
Im: Real
end;
   {Тип  дата рождения}
Data = record
Year: Integer;
Month: 1..12;
Day: 1..31
end;
   {Тип  сведения о сотруднике}
Person = record
Name: string[20];
Sex: (Male, Female);
Age: Integer;
Married: Boolean
end;
Примечание. Если несколько полей типазаписи имеют один и тот же тип, то их имена
можно
перечислить через запятую и затем указать этот общий тип. Так, рассмотренный в примере
тип комплексных чисел можно ввести и другим образом:
type
Complex = record
Re, Im: Real
end; После введения типазаписи можно затем задать переменные или типизированные
константы
этого типа  записи.
При задании значений константе ее поля записываются в круглых скобках через точку с
запятой. Для задания значения каждого поля сначала указывается имя поля, а затем через
двоеточие  его значение.
Так, для введенных выше типов можно задать, например, следующие переменные и
константы:
var
X, У, Z: Complex;
Dat: Data;
const
Birthday: Data = (Year: 1971; Month: 12; Day: 9);
Ivanov: Person = (Name: 'Иванов'; Sex: Male; Age: 40; Married: True);
Примечание. Типзапись можно вводить и непосредственно при определении переменных
или
типизированных констант. Например, фрагмент
var
X, Y, Z: record
Re, Im: Real
end;
определяет те же комплексные переменные, что и в предыдущем примере.
Доступ к полям записи осуществляется указанием имени переменной (константы) и имени
поля,
записываемого через точку, например:
Ivanov.Age, X.Re, Dat.Day и т. д.
Пример.  Использование полей записей.
X.Re := 1.5;
X.Im :=1.7; Y.Re:= X.Re;
Y.Im := X.Im;
Ivanov.Married := False;
Для того чтобы не выписывать каждый раз имя записи при обращении к ее полям, можно
использовать оператор над записями WITH. Его структура выглядит следующим образом:
with <имя записи> do <оператор>;
В  этом  случае внутри  оператора  можно  указывать только  поле  записи. Например,
фрагмент:
with X do begin
  Re := 1.5;
  Im := 1.7;
  Y.Re := Re;
  Y.Im := Im
end;
with Ivanov do
Married := False; эквивалентен фрагменту из предыдущего примера.
Типзапись может иметь вариантную часть, изменяющуюся при разных реализациях,
например,
в типезаписи параметров геометрических фигур для квадрата задается сторона, для
треугольника  две стороны и угол между ними, для окружности  радиус и т. д.
Вариантная часть может быть только одна и должна располагаться в конце записи.
Пример. Использование вариантной части.
type
Figure = (Square, Triangle, Circle);
Param = record
X, Y: Real;
{координаты точки привязки}
case Fig: Figure of{параметры фигур}
Square: (Side: Real);
Triangle: (Sidel, Side2, Angle: Real);
Circle: (Radius: Real)
end;
var MySquare, MyCircle: Param;
Вариантная часть начинается словом case, за которым следует переменная выбора варианта
(в примере Fig) с указанием типа. Далее указываются константы значения которых может
принимать переменная выбора варианта (в примере Square, Triangle, Circle). За каждой
константой через двоеточие в круглых скобках записываются поля данного варианта
записи
с указанием их типов. Круглые скобки необходимы, даже если для данного варианта
вариантная
часть отсутствует. Следует отметить, что вариантная часть не завершается своей
операторной
скобкой end, как у обычной конструкции CASE, т. к. далее идет завершающая операторная
скобка end всего типа.
В стандарте языка Паскаль перед тем, как использовать один из вариантов записи,
переменной
выбора варианта необходимо присвоить соответствующее значение:
Fig := Square;
MySquare.Side :=5.0;
Fig := Circle;
MyCircle.Radius :=7.5;
В Turbo Pascal эту операцию делать необязательно, хотя, если переменная выбора задана,
ее затем можно в программе посмотреть, чтобы определить, какой задан вариант. Более
того,
задание значения переменной выбора ни на что не оказывает влияния, и следующий
фрагмент
эквивалентен рассмотренному выше:
Fig := Circle;
MySquare.Side := 5.0;
Fig := Square;
MyCircle.Radius :7.5; В типзаписи допустимо не вводить переменную выбора вариантов, а перечислить лишь
разные
варианты, например:
Transf = record
case Integer of
1: (_Word: Word);
2: (_TwoSymb: array[1..2] of Char)
end;
6.5. Множество
В языке Паскаль типоммножеством называется множествостепень исходного множества
объектов
порядкового типа, т. е. множество всевозможных сочетаний объектов исходного
множества.
Число элементов исходного множества в Turbo Pascal не может быть больше 256, а
порядковые
номера элементов (т. е. значение функции Ord) должны находиться в пределах от 0 до 255.
Для задания типамножества следует использовать зарезервированные слова set и of, а
затем
указать элементы этого множества, как правило, в виде перечисления или диапазона,
например:
type
Alfa = set of 'A'..'Z';
Count = set of (Plus, Minus, Mult, Divid);
Ten = set of 0..9;
Number = set of '0'..'9' ;
Введя типмножество, можно задать переменные или типизированные константы этого
типамножества.
При задании значений константемножеству ее элементы перечисляются через запятую
(допустимо указывать диапазоны) и помещаются в квадратные скобки. Например, для
введенных
выше типов можно задать такие переменные и типизированные константы:
var
CharVal: Alfa;
Operation: Count;
const
Index: Ten = [0, 2, 4, 6, 8];
Digit: Number = ['0'..'9'];
Примечание.
 Так же как и для других структурированных типов, типмножество можно ввести
непосредственно
при задании переменных или типизированных констант:
var
CharVal: set of 'A'..'Z';
Operation: set of (Plus, Minus, Mult, Divid);
const
Index: set of 0..9 = [0, 2, 4, 6, 8];
Digit: set of '0'..'9'=['0'..'9']; Множеству можно в программе присвоить то или иное значение. Обычно значение задается
с
помощью конструктора множества. Конструктор задает множество элементов с помощью
перечисления в квадратных скобках выражений, значения которых дают элементы этого
множества.
Допустимо использовать диапазоны элементов.
Пример.  Следующие структуры являются конструкторами множеств:
[Plus, Minus]
[1..К mod 12, 15]
[Chr(0)..Chr(31), 'A' , 'В' ]
В каждое множество включается и т. н. пустое множество [ ], не содержащее никаких
элементов.
Конструктор множества можно использовать и непосредственно в операциях над
множествами.
Для множеств определены следующие операции:
+   объединение множеств;
   разность множеств;
*   пересечение множеств;
=   проверка эквивалентности двух множеств;
<>  проверка неэквивалентности двух множеств;
<=  проверка, является ли левое множество подмножеством правого множества;
>=  проверка, является ли правое множество подмножеством левого множества;
in  проверка, входит ли элемент, указанный слева, в множество, указанное справа.
Результатом операции объединения, разности или пересечения является соответствующее
множество, остальные операции дают результат логического типа.
Пример.
 Ввести строку символов, состоящую из латинских букв, цифр и пробелов.
 Осуществить проверку правильности введенных символов.
program EXAMPLE13;
var
Str: string;
L: Byte;
Tru: Boolean;
begin
  WriteLn('Введите строку');
  ReadLn(Str);
  L := Length(str);         {число введенных символов}
  Tru := L > 0;
  while Tru and (L > 0) do
    begin
      Tru:=Str[L] in ['0'..'9', 'A'.,'Z', 'a'..'z', ' '];
      {проверка допустимости символа}
      Dec(L)
    end;
  if Tru then
    WriteLn('Правильная строка') else
    WriteLn('Неправильная строка')
end.
{предыдущий символ}
                {true, если не пустая строка}
{проверка с конца строки} 6.6. Файл
Типфайл представляет собой последовательность компонент одного типа, расположенных
на
внешнем устройстве (в стандарте языка за основу взято расположение данных на
магнитных
лентах). Компоненты могут быть любого типа, за исключением типафайла (или
содержащего
компоненты типафайла) и типаобъекта. Число компонент в файле не объявляется.
Для задания типафайла следует использовать зарезервированные слова file и of, после
чего указать тип компонент файла.
Пример.
type
Number = file of Integer;    {типфайл целых чисел}
Symb = file of 'A'..'Z';     {тип—файл прописных латинских букв}
Стандартный тип Text определяет типфайл, содержащий символы, объединенные в строки.
Следует иметь в виду, что тип Text в Turbo Pascal не эквивалентен типу file of Char.
Введя файловый тип, можно определить переменные файлового типа:
var Fl, F2: Number; F3: Text; FF4: Symb;
В Turbo Pascal можно использовать файл без типа, при определении которого не
указывается
тип компонент. В этом случае работа с файлом осуществляется на физическом уровне в
соответствии с внутренним форматом его данных. При этом реальные компоненты файла
могут
иметь и различный тип.
Пример.
type UnTyp = file;
Типфайл можно определять и непосредственно при объявлении файловых переменных:
var Fl, F2: file of Integer;
Файловые переменные имеют специфическое применение. Над ними нельзя выполнять
никаких
операций (присваивать значение, сравнивать и т. д.). Их можно использовать лишь для
выполнения операций с файлами (чтения, записи, удаления файла и т. д.). Работа с
файлами
будет рассмотрена в п. 11. Кроме того, через файловую переменную можно получить
информацию
о конкретном файле (тип, параметры, имя файла и т. д.)

file_name: тема 2 вопрос 11.docx

intro:
Тип-массив представляет собой фиксированное количество упорядоченных однотипных компонент, снабженных индексами. Он может быть, одномерным и многомерным. Чтобы задать тип-массив, используется зарезервированное слово array, после которого следует указать тип индекса (индексов) компонент (в квадратных скобках) и далее после слова of - тип самих компонент.
type
   <имя типа> = аггау[<тип индекса(индексов)>] of <тип компонент>;
Пример.
type
   Arr = array[1..3] of Real;
   {тип-массив из 3 вещественных чисел}
   Matrix = array[1..3, 1..2] of Integer;
   {тип - двумерный массив целых чисел, состоящий из 3 строк и 2 столбцов}
Введя тип-массив, можно затем задать переменные или типизированные константы этого типа.

информатика

group: Дисциплины

title: Лекция "Структурированные типы данных "


extracted_text:
тема 2 вопрос 12
язык c++ типы данных и операции над данными каждого типа
Символьный тип
Данные типа char в памяти компьютера всегда занимают 1 байт. Символьный тип может
быть со знаком или без него. В величинах со знаком signed char можно хранить значение от
128 до 127. Соответственно значения переменных типа unsigned char могут находиться в
диапазоне от 0 до 255. При работе с символьными данными нужно помнить, что если в
выражении встречается одиночный символ, то он должен быть заключен в одинарные
кавычки (‘a’).
Целочисленный тип
Переменная типа int в памяти компьютера может занимать либо 2, либо 4 байта. Это
зависит разрядности процессора. По умолчанию все целые типы считаются знаковыми, то
есть спецификатор signed можно не указывать. Спецификатор unsigned
позволяетпредставлять только положительные числа. Ниже представлены некоторые
диапазоны значений целого типа

Тип
int
unsigned int
signed int
short int
long int
unsigned short int 0…65535
Диапазон
Размер
2147483648…2147483647 4 байта
0…4294967295
4 байта
2147483648…2147483647 4 байта
32768…32767
2 байта
2147483648…2147483647 4 байта
2 байта
Вещественный тип
Число с плавающей точкой представлено в форме mE + p, где m — мантисса (целое или
дробное число с десятичной точкой), p — порядок (целое число). Обычно величины типа
float занимают 4 байта, а double 8 байт. Таблица диапазонов значений вещественного типа:

4 байта
float
double
8 байт
long double 3,4E4932…3,4E+4932 8 байт
3,4E38…3,4E+38
1,7E308…1,7E+308
Логический тип
Переменная типа bool может принимать только два значения true (истина) или  fasle
(ложь). Любоезначение, не равное нулю, интерпретируется как true. Значение false
представлено в памяти как 0.
Тип void
Множество значений этого типа пусто. Он используется для определения функций,
которые не возвращают значения, для указания пустого списка аргументов функции, как
базовый тип для указателей и в операции приведения типов.
Преобразование типов данных
В C++ различают два вида преобразования типов данных: явное и неявное.
 Неявное преобразование происходит автоматически. Это выполняется во время
сравнения,  присваивания или вычисления выражения различных типов. Например,
следующая программа выведет на консоль значение типа float.

1
2
#include "stdafx.h"
#include  3
4
5
6
7
8
9
1
0
using namespace std;
int main()
{
int i=5; float f=10.12;
cout<>void");
return 0;
}

Наивысший приоритет получает тот тип, при котором информация теряется менее всего.
Не стоит злоупотреблять неявным преобразованием типов, так как могут возникнуть
разного рода непредвиденные ситуации.
 Явное преобразование в отличие от неявного осуществляется программистом.
Существует несколько способов такого преобразования:
1. Преобразование в стили C: (float) a
2. Преобразование в стили C++: float()
Также приведения типов может осуществляться при помощи следующих операций:

1
2
3
4
static_cast <> ()
const_cast <> ()
reinterpret_cast <> ()
dynamic_cast <> ()

static_cast — осуществляет преобразование связанных типов данных. Этот оператор
приводит типы по обычным правилам, что может потребоваться в случае, когда
компилятор не выполняет автоматическое преобразование. Синтаксис будет выглядеть
так:
Тип static_cast <Тип> (объект);
С помощью static_cast нельзя убрать константность у переменной, но это по силам
следующему оператору. const_cast — применяется только тогда, когда нужно снять
константность у объекта. Синтаксис будет выглядеть следующим образом:
Тип const_cast <Тип> (объект);
reinterpret_cast  применяется для преобразования указателей разных типов, целых к
указателю и наоборот. Если вы увидели новое слово «указатель» — не пугайтесь! это тоже
тип данных, но работать с ним Мы будем не скоро. Синтаксис тут такой же как, у ранее
рассмотренных операторах:
Тип reinterpret_cast <Тип> (объект);
dynamic_cast — используется для динамического преобразования типов, реализует
приведение указателей или ссылок. Синтаксис:
Тип dynamic_cast <Тип> (объект);
Описание переменной: тип_переменной имя_переменной(идентификатор)
Пример описания:
int A,B;
double D;
char K;
Тип переменной определяет диапазон допустимых значений, принимаемых величинами
этого типа; набор операций, допустимых над данной величиной и объем памяти,
отводимой под эту переменную.
Каждый тип имеет свой идентификатор. Идентификато
р
Размер,
бит
Диапазон (множество)
значений
Примечание
unsigned char
char
enum
unsigned int
short int
int
8
8
16
16
16
16
0..255
128..127
32768..32767
0..65535
32768..32767
32768..32767
unsingned long 32
32
long
0..4294967295
2147483648..2147483647
float
double
long double
32
64
80
3.4E38..3.4E+38
1.7E308..1.7E+308
3.4E4932..1.1E+4932
Небольшие целые числа и коды
символов
Очень малые целые числа и
ASCIIкоды
Упорядоченные наборы целых
значений
Большие целые и счетчики циклов
Небольшие целые, управление
циклами
Небольшие целые, управление
циклами
Астрономические расстояния
Большие числа, популяции
Научные расчеты (7 значащих
цифр)
Научные расчеты (15 значащих
цифр)
Финансовые расчеты (19 значащих
цифр)
Обмен информацией с ЭВМ предполагает использование определенных средств ввода
вывода. В ЭВМ основным средством ввода является клавиатура, вывода — дисплей.
В языке C++ функция (метод), которая в режиме диалога с клавиатуры присваивает
значение для переменной величины, выглядит следующим образом:
cin >> переменная;
Например,
float A; int B; char C;
cin >> A;
cin >> B;
cin >> C;
Читается: "Ввести вещественную А, целую В и символьную С".
Получим тот же результат, если запишем:
float A; int B; char C;
cin >> A >> B >> C;
В этом случае, как только в программе встречается вызов cin, ЭВМ приостанавливает
выполнение этой программы и ждет, пока пользователь введет с клавиатуры
соответствующие значения, которые по очереди будут присваиваться переменным,
перечисленным в списке ввода. Значения вводимых данных одновременно отображаются на
экране дисплея. После нажатия клавиши enter, когда все переменные примут свои
значения из входного набора данных, определенного пользователем, выполнение
программы продолжается с оператора, следующего за cin.
В С++ команда, которая выводит содержимое переменных (выражений) на экран, выглядит
следующим образом
cout << переменная;
Например
cout << "Выходное значение: " << C;
В списке вывода этих операторов может быть либо одно выражение, либо
последовательность таких выражений, аналогично функции cin.
Для управления размещением выводимых значений функция cout используется с
форматом. Под форматом данных понимается расположение и порядок кодирования
отдельных полей элементов данных. Для такого форматирования применяется функция:
cout.width(колво_позиций);
В языке C++ также существуют перечислимый тип – enum, который является
подмножеством целого типа, и пустой тип – void, который имеет специальное назначение.
Он используется для объявления функций, которые не возвращают никакого значения, а
также для объявления указателей на значение типа void. Такие указатели могут быть
преобразованы к указателям на любой другой тип.
В языке С++ можно объявлять структуры и так называемые объединения.
В языке C++ нет специальных типов для массивов и строк, которые представляются
массивом символов.
В языке С не существовало логического типа. Логические значения представлялись
данными целого типа, при этом значение 0 соответствовало логическому значению ложь, а
все остальные целые значения соответствовали логическому значению истина. В языке
С++ сохранена данная логика. По определению, true имеет значение 1 при преобразовании
к целому типу, а false – значение 0. И наоборот, целые можно неявно преобразовать в
логические значения: при этом ненулевые целые преобразуются в true, а ноль – в false. В
любом месте, где требуется логическое значение, может стоять целочисленное выражение.
В арифметических и логических выражениях логические значения преобразуются в целые,
операции выполняются над преобразованными величинами.
Указатель можно неявно преобразовать в логическое значение, при этом ненулевой
указатель принимает значение true, нулевой – false.
Такой подход позволяет вместо логической и целочисленной переменных объявлять только
целочисленную, при этом значение переменной, равное 0, говорит об отсутствии
некоторого признака у объекта, а остальные значения говорят о его наличии, и при этом
несут какуюлибо дополнительную информацию.
При выполнении бинарных операций производятся преобразования по умолчанию для
приведения операндов к одному и тому же типу, который потом используется как тип
результата:
1. если один из операндов имеет тип long double, другой тоже преобразуется в long
double;
иначе, если один операнд имеет тип double, то второй операнд преобразуется
к типу double;
иначе, если один операнд имеет тип float, то второй операнд преобразуется к
типу float;
иначе над обоими операндами производится интегральное продвижение, а
именно: значения типов char, signed char, unsigned char, short int и unsigned
short int преобразуются в int, если int может представить все значения
исходных типов, в противном случае они преобразуются в unsigned int; bool
преобразуется в int.







2.
затем если один операнд имеет тип unsigned long, то второй операнд преобразуется
к типу unsigned long;
иначе, если один из операндов относится к типу long int, а другой к типу
unsigned int, то если long int может представить все значений типа unsigned
int, unsigned int преобразуется в long int, иначе оба операнда преобразуются в
unsigned long int;
иначе, если один операнд имеет тип long int, то второй операнд
преобразуется к типу long int;
иначе, если один операнд имеет тип unsigned int, то второй операнд
преобразуется к типу unsigned int;
иначе оба операнда имеют тип int. В языке С++ нет операций преобразования между символом и кодом символа, т.к. в
оперативной памяти символ и так хранится в виде его кода. Поэтому можно к переменной,
хранящей символ, прибавить 1 и получить следующий символ.
5. Операции языка C++
Данная таблица описывает операции языка C++. Операции разделены на группы,
расположенные в порядке убывания приоритета операций.
Знак операции
Наименование
Ассоциативность
::
Разрешение области видимости
Слева направо

( )    [ ]    .          >
++

static_cast
dynamic_cast
reinterpret_cast
const_cast
    ~    !    *    &
++

sizeof
(<   тип
new
delete
 >)<
 выражение

 >
.  *             >   *
*    /    %
+
<<

        >>
<    >    <=    >=
==    !=
&
^
|
&&
||
? :
Первичные
Постфиксный инкремент и
декремент
Преобразование с проверкой во
время компиляции
Преобразование с проверкой во
время выполенения
Преобразование без проверки
Константное преобразование
Унарные
Префиксный инкремент и
декремент
Вычисление размера
Приведение типа
Выделение памяти
Освобождение памяти
Выбор члена класса
Мультипликативные
Аддитивные
Сдвиг
Отношение
Отношение
Поразрядное И
Слева направо
Справа налево
Слева направо
Слева направо
Слева направо
Слева направо
Слева направо
Слева направо
Слева направо
Поразрядное исключающее ИЛИ
Слева направо
Поразрядное ИЛИ
Логическое И
Логическое ИЛИ
Условная операция
Слева направо
Слева направо
Слева направо
Справа налево
=           *=
        /=
        %=
        +=
        =

        <<=
         Простое и составное присваивания  Справа налево Знак операции
Наименование
Ассоциативность
>>=

        &=

        ^=
        |=

Генерация исключения
Слева направо
Операция последовательного
вычисления
Слева направо
throw
,




:: – операция разрешения области видимости. При повторном объявлении имени во
вложенном блоке или классе предыдущие объявления оказываются скрытыми.
Однако скрытое имя члена класса можно использовать, квалифицировать его
именем класса при помощи операции разрешения области видимости. Скрытое
глобальное имя можно использовать, если квалифицировать его унарной операцией
разрешения области видимости.
( ) – выражение в скобках (используется для изменения порядка вычисления) или
вызов функции.
[ ] – индексное выражение, используется для работы с массивами.
. и > – выбор элемента, используются при работе с классами, структурами и
объединениями.
 Операции static_cast (преобразование с проверкой во время компиляции),
dynamic_cast (преобразование с проверкой во время выполнения), reinterpret_cast
(преобразование без проверки), const_cast (константное преобразование)
осуществляют различные преобразования типов. Они имеют следующий синтаксис:
операция<новый тип>(выражение). Угловые скобки являются элементом
синтаксиса. Операция static_cast осуществляет преобразование родственных типов,
например, указателя на один тип к указателю на другой тип из той же иерархии
классов, целый тип в перечисление или тип с плавающей точкой в интегральный.
Операция reinterpret_cast управляет преобразованиями между несвязанными
типами, например, целых в указатели или указателей в другие (несвязанные)
указатели. Такое различие позволяет компилятору осуществлять минимальную
проверку типов при использовании static_cast, а программисту – легче обнаружить
опасные преобразования, представляемые reinterpret_cast. Преобразование
dynamic_cast выполняется и проверяется на этапе выполнения. Преобразование
const_cast аннулирует действие модификатора const.
 – унарный минус.
~ – обратный код (см. лекцию 8).
! – логическое отрицание.
* – косвенная адресация (см. лекцию 5).




 & – адресация (см. лекцию 5).
 Операции ++ и  инкрементируют (увеличивают на 1) и декрементируют
(уменьшают на 1) свой операнд. Операнд должен иметь целый, вещественный тип
или быть указателем. Операции инкремента и декремента могут записываться как
перед своим операндом (префиксная форма записи), так и после него (постфиксная
форма записи). При префиксной форме записи операнд сначала инкрементируется
или декрементируется, а затем его новое значение участвует в дальнейшем
вычислении выражения, содержащего данную операцию. При постфиксной форме
записи операнд инкрементируется или декрементируется лишь после того, как его
старое значение участвует в вычислении выражения. Таким образом, результатом
операций инкремента и декремента является либо новое, либо старое значение
операнда. Например, если переменная i = 0, то выражение a[++i] = 1 меняет элемент a[1], а выражение a[i++] = 1 меняет элемент a[0]. В обоих случая переменная i
получает новое значение, равное 1.
sizeof – вычисление размера в байтах переменной или типа.

 Операция приведения типа записывается следующим образом: (<новый
тип>)<выражение>. Например, (long int)n приводит переменную n к типу long int.
При преобразовании типов надо помнить, что при преобразовании между
знаковыми/беззнаковыми значениями и при преобразовании от типа с большей
размерностью к типу с меньшей размерностью могут возникнуть ошибки. Более
безопасным способом преобразования типов является использование операций
static_cast, dynamic_cast, reinterpret_cast и const_cast.
 % – остаток от деления.
 В языке C++ имеется одна тернарная операция – условная операция. Она имеет
следующий синтаксис: <операнд 1> ? <операнд 2> : <операнд 3>. Если <операнд 1>
имеет ненулевое значение, то вычисляется <операнд 2> и результатом условной
операции является его значение. Если же <операнд 1> равен нулю, то вычисляется
<операнд 3> и результатом является его значение. В любом случае вычисляется
только один из операндов, <операнд 2> или <операнд 3>, но не оба.
 Простое присваивание. Операция простого присваивания обозначается знаком
«=». Значение правого операнда присваивается левому операнду. Операция
вырабатывает результат, который может быть далее использован в выражении.
Результатом операции является присвоенное значение. Например, выражение a = b =
c = 0 присваивает всем переменным значение 0, а в результате вычисления
выражения a = (b = 3) + (c = 5) переменная c будет иметь значение 5, переменная b
будет иметь значение 3, и переменная a будет иметь значение 8.
 Составное присваивание. Операция составного присваивания состоит из простой
операции присваивания, скомбинированной с какойлибо другой бинарной
операцией. При составном присваивании вначале выполняется действие,
специфицированное бинарной операцией, а затем результат присваивается левому
операнду. Оператор n += 5 эквивалентен оператору n = n + 5, но при этом первый
оператор легче для понимания и выполняется быстрее.
 Операция последовательного вычисления «,» обычно используется для
вычисления нескольких выражений в ситуациях, где по синтаксису допускается
только одно выражение. Однако, запятая, разделяющая параметры функции, не
является операцией последовательного вычисления.
Порядок вычислений подвыражений внутри выражений не определён. В частности, не стоит
предполагать, что выражения вычисляются слева направо.
int x = f(2) + g(3);
// Неизвестно, какая функция вызовется первой – f()
или g()
При отсутствии ограничений на порядок вычислений можно сгенерировать более
качественный код. Однако отсутствие ограничений на порядок вычислений может
привести к неопределённым результатам.
Логические операции «И» и «ИЛИ», условная операция и операция последовательного
вычисления гарантируют определенный порядок вычисления своих операндов.
Условная операция вычисляет сначала свой первый операнд, а затем, в зависимости от его
значения, либо второй, либо третий операнд. Логические операции также обеспечивают
вычисление своих операндов слева направо, причём логические операции вычисляют
минимальное число операндов, необходимое для определения результата выражения.
Таким образом, второй операнд выражения может вообще не вычисляться. Операция
последовательного вычисления обеспечивает вычисление своих операндов по очереди,
слева направо. Обратите внимание, что запятая в качестве указателя последовательности логически отличается от запятой, используемой в качестве разделителя параметров при
вызове функций.
f1(v[i], i++);
f2((v[i], i++));
// Два параметра
// Один параметр
Вызов функции f1 осуществляется с двумя параметрами v[i] и i++, и порядок вычисления
параметров не определён. Расчет на определённый порядок вычисления параметров
является исключительно плохим стилем и приводит к непредсказуемому поведению
программы. Вызов функции f2 имеет один параметр – последовательность выражений,
разделённых запятой. Порядок вычисления гарантирован, и вызов эквивалентен f2(i++).

file_name: тема 2 вопрос 12.docx

description:
тема 2 вопрос 12
язык c++ типы данных и операции над данными каждого типа
Символьный тип
Данные типа char в памяти компьютера всегда занимают 1 байт. Символьный тип может
быть со знаком или без него. В величинах со знаком signed char можно хранить значение от
128 до 127. Соответственно значения переменных типа unsigned char могут находиться в
диапазоне от 0 до 255. При работе с символьными данными нужно помнить, что если в
выражении встречается одиночный символ, то он должен быть заключен в одинарные
кавычки (‘a’).
Целочисленный тип
Переменная типа int в памяти компьютера может занимать либо 2, либо 4 байта. Это
зависит разрядности процессора. По умолчанию все целые типы считаются знаковыми, то
есть спецификатор signed можно не указывать. Спецификатор unsigned
позволяетпредставлять только положительные числа. Ниже представлены некоторые
диапазоны значений целого типа

Тип
int
unsigned int
signed int
short int
long int
unsigned short int 0…65535
Диапазон
Размер
2147483648…2147483647 4 байта
0…4294967295
4 байта
2147483648…2147483647 4 байта
32768…32767
2 байта
2147483648…2147483647 4 байта
2 байта
Вещественный тип
Число с плавающей точкой представлено в форме mE + p, где m — мантисса (целое или
дробное число с десятичной точкой), p — порядок (целое число). Обычно величины типа
float занимают 4 байта, а double 8 байт. Таблица диапазонов значений вещественного типа:

4 байта
float
double
8 байт
long double 3,4E4932…3,4E+4932 8 байт
3,4E38…3,4E+38
1,7E308…1,7E+308
Логический тип
Переменная типа bool может принимать только два значения true (истина) или  fasle
(ложь). Любоезначение, не равное нулю, интерпретируется как true. Значение false
представлено в памяти как 0.
Тип void
Множество значений этого типа пусто. Он используется для определения функций,
которые не возвращают значения, для указания пустого списка аргументов функции, как
базовый тип для указателей и в операции приведения типов.
Преобразование типов данных
В C++ различают два вида преобразования типов данных: явное и неявное.
 Неявное преобразование происходит автоматически. Это выполняется во время
сравнения,  присваивания или вычисления выражения различных типов. Например,
следующая программа выведет на консоль значение типа float.

1
2
#include "stdafx.h"
#include <iostream>

description:
3
4
5
6
7
8
9
1
0
using namespace std;
int main()
{
int i=5; float f=10.12;
cout<<i/f;
system("pause>>void");
return 0;
}

Наивысший приоритет получает тот тип, при котором информация теряется менее всего.
Не стоит злоупотреблять неявным преобразованием типов, так как могут возникнуть
разного рода непредвиденные ситуации.
 Явное преобразование в отличие от неявного осуществляется программистом.
Существует несколько способов такого преобразования:
1. Преобразование в стили C: (float) a
2. Преобразование в стили C++: float()
Также приведения типов может осуществляться при помощи следующих операций:

1
2
3
4
static_cast <> ()
const_cast <> ()
reinterpret_cast <> ()
dynamic_cast <> ()

static_cast — осуществляет преобразование связанных типов данных. Этот оператор
приводит типы по обычным правилам, что может потребоваться в случае, когда
компилятор не выполняет автоматическое преобразование. Синтаксис будет выглядеть
так:
Тип static_cast <Тип> (объект);
С помощью static_cast нельзя убрать константность у переменной, но это по силам
следующему оператору. const_cast — применяется только тогда, когда нужно снять
константность у объекта. Синтаксис будет выглядеть следующим образом:
Тип const_cast <Тип> (объект);
reinterpret_cast  применяется для преобразования указателей разных типов, целых к
указателю и наоборот. Если вы увидели новое слово «указатель» — не пугайтесь! это тоже
тип данных, но работать с ним Мы будем не скоро. Синтаксис тут такой же как, у ранее
рассмотренных операторах:
Тип reinterpret_cast <Тип> (объект);
dynamic_cast — используется для динамического преобразования типов, реализует
приведение указателей или ссылок. Синтаксис:
Тип dynamic_cast <Тип> (объект);
Описание переменной: тип_переменной имя_переменной(идентификатор)
Пример описания:
int A,B;
double D;
char K;
Тип переменной определяет диапазон допустимых значений, принимаемых величинами
этого типа; набор операций, допустимых над данной величиной и объем памяти,
отводимой под эту переменную.
Каждый тип имеет свой идентификатор.

title: Лекция "Язык c++ типы данных "


extracted_text:
тема 2 вопрос 23
ПРИНЦИПЫ ОБЪЕКТНООРИЕНТИРОВАННОГО ПРОГРАММИРОВАНИЯ примеры
    Объектноориентированный язык программирования характеризуется тремя основными свойствами:
    Инкапсуляция  объединение в одном объекте данных и методов их обработки.
    Наследование  создание новых объектов на базе ранее определенных. Новые объектыпотомки
сохраняют свойства своих родителей и обладают специфическими свойствами.
    Полиморфизм  возможность замещения методов объектародителя одноименными методами
объектапотомка.
    Основная программа не должна иметь непосредственного доступа к данным объекта, кроме как при
помощи методов самого объекта. Методы объекта должны обрабатывать лишь данные своего объекта,
не влияя на значение глобальных переменных и не обращаясь к данным другого объекта. Выполнение
этих принципов обеспечивает надежность ООП, хорошую защиту от ошибок и возможность
использования одних и тех же объектов различными программами.
    Преимущества ООП в полной мере проявляются при разработке достаточно сложных программ.
Инкапсуляция придает объектам совершенно особое свойство "самостоятельности", максимальной
независимости от остальных частей программы. Правильно сконструированный объект располагает
всеми необходимыми данными и процедурами их обработки, чтобы успешно реализовать требуемые от
него действия. Попытки использовать ООП для программирования несложных алгоритмических
действий выглядят искусственными нагромождениями ненужных языковых конструкций.
Основные принципы объектноориентированного программирования
Объектноориентированное программирование — это сравнительно молодая концепция, получившая
широкое распространение только в середине 1980х гг. До этого программирование было
исключительно процедурным. Что отличает объектноориентированное программирование от
процедурного? Отвечая на этот вопрос, можно выделить три основных принципа объектно
ориентированного программирования: абстракцию, инкапсуляцию, наследование.
Главным преимуществом объектноориентированного подхода является широкое использование
инкапсуляции. Инкапсуляция (или скрытие реализации) позволяет создавать программу в виде
отдельных, в большей или меньшей степени изолированных блоков. Почему программу приходится
разбивать на такие блоки? Вы имеете уже достаточный опыт в написании сценариев, чтобы понимать,
что, каким бы опытным ни был специалист, проследить логику кода из более чем 35 тысяч строчек ему
не удастся — это просто выше человеческих интеллектуальных способностей. Современные же
программы образованы миллионами и десятками миллионов строчек кода. Естественно, что написать
конкурентноспособный коммерческий продукт один человек вряд ли может. Над созданием программ
работают группы кодеров, и порой весьма значительные (так, штат Microsoft — многие тысячи
программистов и тестеров). Каждый из программистов в таких командах создает свой фрагмент кода.
Далее все фрагменты объединяются в единый блок, производятся тестирование, отладка и т. д.
Подумайте, если бы область видимости для всех фрагментов программы была единой — какие
огромные проблемы возникли бы, например, изза конфликта имен. Чтобы избежать этого, каждый
программист должен был бы знать, как именно peaлизован участок кода, написанный его коллегой. А
если переменных в программе тысячи? В этом случае основное время кодера ухолило бы на подбор
идентификаторов, а не на создание алгоритма.
Решением описанной проблемы является инкапсуляция кода. Инкапсулированный фрагмент программы
может быть представлен в виде «черного ящика», получающего на входе данные и выдающего на
выходе результат. Переменные и функции инкапсулированного кода обладают локальной видимостью,
поэтому случайно изменить их извне невозможно. Это решает проблему конфликта имен. При
использовании инкапсуляции кода программист совершенно не должен задумываться о том, какреали
зованы остальные блоки программы. Он должен знать лишь то, что блок X выполняет те или иные
задачи, и иногда — в какой форме он принимает данные на обработку. Поэтому инкапсуляция значительно облегчает разработку программ — создать без нее код более чем из тысячи строчек очень
сложно. Инкапсуляция присуща не только объектноориентированному программированию. Так, в
процедурном программировании она реализуется, например, при помощи подпрограмм (как вы
помните, в ActionScript подпрограммы называются функциями). Однако в объектноориентированном
программировании ее применение значительно расширяется благодаря введению понятия объекта.
Объект — это группа переменных и подпрограмм, объединенных в одну структуру по принципу
выполняемых функций. В объектноориентированном программировании переменные объекта принято
называть свойствами, а подпрограммы — методами. Свойства определяют состояние объекта, методы
— его поведение. Методы, как правило, служат для изменения состояния объекта, т. е. при вызове
нужным образом переопределяют его свойства, Свойства и методы объекта могут обладать разной
степенью доступности. Они могут быть внутренними — при этом извне к ним нельзя получить доступ,
допускающими только чтение, позволяющими чтение и переопределение, и наконец, доступными для
чтения, удаления и переопределения. Разная степень доступности свойств позволяет минимизировать
вероятность сбоя в работе всей системы при ошибочном удалении или переопределении одного из
свойств. В ActionScript свойства и методы всех встроенных объектов защищены от удаления и
перечисления циклом for—in, для большинства недопустимо также переопределение.
Смысл введения понятия «объект» достаточно очевиден. Вопервых, все методы и свойства,
выполняющие задачи одного типа, можно собрать в одном месте, что значительно повышает общую
стройность программы. Вовторых, возможно инкапсулировать переменные и подпрограммы.
Польза от этого огромна. Например, слияние строк и объединение массивов выполняют методы с одним
именем — concat(). Подобная перегруженность идентификатора возможна потому, что данные методы
разделены по разным объектам. Втретьих, понятие объекта чрезвычайно близко к стереотипам нашего
мышления, что делает программирование на объектноориентированном языке более интуитивным по
сравнению с процедурным программированием. В этом проявляется одна из основных концепций
объектноориентированного программирования — абстракция.
Часто в программе должно быть несколько однотипных объектов. Создавать их копированием кода не
очень технично, так как это приведет к увеличению размера программы. Обычно объекты формируются
на базе шаблона, называемого классом, с использованием оператора new. Например, строка new Ball()
создаст новый объект класса Ball. Объекты класса называют его экземплярами.
Все методы и свойства, которые должны быть присущи объект, прописываются в его классе. Роль
объекта и класса объектов не ограничивается объединением и инкапсуляцией переменных и
подпрограмм. С ними связано второе важнейшее понятие объектноориентированного
программирования — наследование.
Наследование — это передача переменных и функций между двумя независимыми модулями
программы. Зачем нужно наследование? Прежде всего, оно позволяет минимизировать размер
программы, а также трудоемкость ее создания. Представьте, что вы решили написать собственный
графический редактор и вам надо разработать инструменты Line и Rectangle. Очевидно, что часть
методов в объектах, их реализующих, будет одинакова. Например, идентичны в них будут методы,
рисующие прямую линию. Имеет смысл данные методы вынести в отдельный объект, а в объектах Line
и Rectangle оставить пометку о том, что если методы с такими именами потребуются, то они должны
быть позаимствованы в хранящем их объекте. При этом отпадает необходимость дважды переписывать
один и тот же код, а также сокращается длина программы.
Как вы помните, объекты создаются на базе определений классов. При этом часть свойств и методов
может передаваться объекту непосредственно, а часть им наследуется. Непосредственно переносятся
на объект те свойства и методы, которые должны иметь для каждого экземпляра класса
индивидуальные значения. Те же компоненты определения класса, которые должны быть одинаковы для всех объектов, ими наследуются.
Класс может наследовать свойства другого класса. При этом данный класс будет являться по
отношению к объектам первого суперклассом. Вообше протяженность цепочки наследования может
быть любой. В некоторых языках цепочка наследования может даже ветвиться.
Важнейшей концепцией объектноориентированной модели является полиморфизм. Как следует из
названия этого понятия, оно должно означать множественность форм. И действительно, полиморфизм
обозначает способность объекта менять форму в процессе выполнения программы.
Если вы новичок в программировании, приведенное описание принципов объектноориентированного
программирования может показаться вам малопонятным. В этом случае попробуйте связать в своем
сознании понятия объектноориентированного программирования с предметами из реальной жизни. Это
можно сделать, так как объектноориентированное программирование разрабатывалось именно для
того, чтобы «очеловечить» программирование, сделать написание программ более близким
особенностям нашего мышления.
Попробуем сопоставить понятия объектноориентированного программирования с обычным котом.
Действительно, вполне можно считать, что идущий по крыше кот — это объект. Он обладает
свойствами — окрасом, размером, возрастом и пр. Свойства кота делятся на индивидуальные (к
примеру, цвет глаз) и присущие всему множеству (называемому в объектноориентированном
программировании классом) котов (например, строение сердца). В свою очередь класс котов во многом
схож с классом млекопитающих (например, количеством лап или способом вскармливания потомства)
и, следовательно, является его подклассом. Любой класс может порождать подклассы, наследующие
его свойства — так, в вид «кот домашний» входят тысячи самых разнообразных пород. В этом
выражается концепция наследования. Коту присущи методы — алгоритмы, меняющие его свойства. К
примеру, хлопок холодильника — безотказный метод, меняющий свойство положения кота на значение,
совпадающее с координатой кухни. Чтобы позвать нашего питомца на обед, совсем не обязательно знать
его анатомию и особенности нервной деятельности.
Для этого достаточно владеть внешним «интерфейсным» методом «кискис». В этом заключается еще
один важный принцип объектноориентированного программирования — инкапсуляция (или скрытие
реализации). На действие одного и того же метода разные коты могут реагировать поразному. Так,
услышав лай собаки, более осторожное животное залезет на дерево, а более смелое продолжит спать
как ни в чем не бывало. В терминах объектноориентированного программирования подобное
поведение объектов одного класса называется полиморфизмом.
Принципы объектноориентированного программирования
Объектноориентированное программирование развивается уже более двадцати лет. Имеется несколько
школ, каждая из которых предлагает свой набор принципов работы с объектами и посвоему излагает
эти принципы. Но есть несколько общепринятых понятий. Перечислим их.





Абстракция
Иерархия
Ответственность
Модульность
Принцип KISS

file_name: тема 2 вопрос 23.docx

intro:
Объектно-ориентированное программирование — это сравнительно молодая концепция, получившая широкое распространение только в середине 1980-х гг. До этого программирование было исключительно процедурным. Что отличает объектно-ориентированное программирование от процедурного? Отвечая на этот вопрос, можно выделить три основных принципа объектно-ориентированного программирования: абстракцию, инкапсуляцию, наследование.

Главным преимуществом объектно-ориентированного подхода является широкое использование инкапсуляции. Инкапсуляция (или скрытие реализации) позволяет создавать программу в виде отдельных, в большей или меньшей степени изолированных блоков.

title: Лекция "ПРИНЦИПЫ ОБЪЕКТНО-ОРИЕНТИРОВАННОГО ПРОГРАММИРОВАНИЯ "


extracted_text:
характеристика ИНТЕГРИРОВАННой СРЕДы РАЗРАБОТКИ программ Delphi
тема 2 вопрос 25
    Основой Delphi является графическая среда разработки приложений, называемая интегрированной
средой разработки (Integrated Development Environment, IDE). Многие известные в данный момент
приложения для Windows имеют MDI (Multiple Document Interface), который определяет особый способ
управления нескольких дочерних окон внутри одного большого окна. Представителем MDIприложения
является текстовый редактор Word. Среда Delphi является представителем спецификации, называемой
Single Document Interface (SDI), и состоит из нескольких отдельно расположенных окон. SDI ближе к той
модели приложений, что используется в Windows 95. Окна могут перемещаться по экрану, частично или
полностью перекрывать друг друга. Каждое окно предназначено для решения определенных задач. На рис.
1 показан вид экрана после запуска Delphi. На рис. 1 приведено окно Delphi 3. Для других версий окна
будут иметь незначительные отличия.
    После запуска Delphi на экране открываются четыре окна интегрированной среды разработки
приложений.
    Главные составные части среды программирования:
    1. Главное окно.
    2. Окно формы.
    3. Окно редактора кода программы.
    4. Инспектор объектов.
    В верхней части экрана расположено главное окно (рис. 2). Оно имеет заголовок Delphi 3  Project1. В
строке заголовка главного окна отображается имя открытого в данный момент проекта: Project1. В
главном окне находится строка главного меню, панели инструментов и панели компонентов. Главное окно
программы остается открытым все время, пока остается загруженной Delphi. Закрыть главное окно
значит закончить работу с системой программирования.
    Строка меню содержит команды, необходимые для разработки и тестирования приложений, а также
управления ими.
    Панель инструментов (рис. 3) содержит кнопки, которые соответствуют определенным командам меню,
например командам File, View и др. Щелчок на какойлибо из кнопок приводит к тому же результату, что
и выбор соответствующей команды в главном меню.
    В палитре компонентов (рис. 4) отображаются компоненты, с помощью которых пользователь создает
свои приложения. Компоненты являются основными элементами каждого Delphi приложения и,
одновременно, основой библиотеки визуальных компонентов  Visual Component Library (VCL). Они
позволяют создавать пользовательский интерфейс прикладных программ.
    Под компонентом понимается некий функциональный элемент, имеющий определенные свойства и
размещаемый программистом в окне формы. С помощью компонентов создается каркас программы, во
всяком случае,  ее видимые на экране внешние проявления: окна, кнопки, списки выбора и т.д. После
запуска Delphi активной является страница Standard палитры компонентов. Выбрать другую страницу
можно щелчком на вкладке с соответствующим названием.
    Окно формы (рис. 5) представляет собой проект Windowsокна будущей программы. Форма  это окно
приложения на этапе разработки. Вначале окно формы содержит только стандартные для Windows
интерфейсные элементы  кнопки вызова системного меню, максимизации, минимизации и закрытия окна,
полосу заголовка и очерчивающую рамку. Вся рабочая область заполнена точками координатной сетки,
служащей для упорядочения размещаемых на форме компонентов. Для каждого нового проекта
автоматически создается главное окно будущего приложения и по умолчанию оно имеет имя Form1.
    Работа с формой в Delphi интуитивно понятна. Создание интерфейса превращается в детскую игру.
Значительную часть времени программист занят увлекательным занятием, напоминающим работу с
набором деталей конструктора Lego: он "достает" из палитры компонентов, как из коробки с деталями,
нужный компонент и размещает его на "наборном поле" окна формы, постепенно заполняя форму
интерфейсными элементами.
    Окно редактора текста программы на рис. 1 расположено позади окна формы. Оно предназначено для
создания и редактирования текста программы. Этот текст составляется по специальным правилам и
описывает алгоритм работы программы.
    Создавая программы на Delphi, программисты постоянно переходят от окна формы к окну программы и
обратно. Первоначально окно программы содержит минимальный исходный текст, обеспечивающий нормальное функционирование пустой формы в качестве полноценного Windowsокна. В ходе работы над
проектом программист вносит в него необходимые дополнения, чтобы придать программе нужную
функциональность. Между содержимым окон формы и программы существует неразрывная связь, которая
строго отслеживается Delphi. Размещение на форме компонента приводит к автоматическому изменению
текста программы. Удаление тех или иных автоматически вставленных фрагментов текста программы
может привести к удалению соответствующих компонентов.
    С помощью окна инспектора объектов (рис. 7) задаются и редактируются свойства и обработчики
событий компонентов. Инспектор объектов является инструментом, который используется для
формирования внешнего вида и функциональных возможностей формы и компонентов в процессе
разработки приложения. Любой размещаемый на форме компонент характеризуется некоторым набором
параметров: положением, размером, цветом и т.д. Часть этих параметров, например, положение и размеры
компонента, программист может изменять, манипулируя с компонентом в окне формы.
    Окно инспектора объектов содержит две страницы, каждую из которых можно активизировать,
выполнив щелчок на вкладке с соответствующим названием. Первая страница имеет название Properties
(свойства). Левая колонка этой страницы содержит список всех свойств редактируемого компонента,
доступных во время проектирования. Вторая страница называется Events (события). В ее левой колонке
перечислены все имеющиеся обработчики событий компонента. Совокупность событий определяет
поведенческую сторону компонента, т. е. будет ли компонент реагировать на щелчок мыши или нажатие
клавиши, как он будет вести себя в момент появления на экране. В правых колонках обеих страниц могут
устанавливаться значения соответствующих свойств или обработчиков событий.
    Некоторые свойства, отображенные на странице Properties, имеют начальные значения. Строки таблицы
выбираются щелчком мыши и могут отображать простые или сложные свойства. К простым свойствам
относятся свойства, определяемые единственным значением  числом, строкой символов, значением True
или False и т.д. Сложные свойства определяются совокупностью значений. Слева от имени таких свойств
указывается значок "+", а двойной щелчок мышью на имени свойства приводит к раскрытию списка
составляющих сложного свойства. Для ряда свойств компонентов в правом конце строки может появиться
одна из кнопок: . Нажатие кнопки приводит к появлению на экране диалогового окна или списка
возможных свойств.
    В инспекторе объектов приведены только те свойства, которыми обладает данный компонент во время
проектирования приложения. Полный список свойств, которыми данный компонент обладает во время
выполнения приложения, можно получить с помощью системы подсказок Delphi.
    В верхней части окна инспектора объектов располагается раскрывающийся список всех помещенных на
форму компонентов. Поскольку форма сама по себе является компонентом, ее имя также присутствует в
этом списке.
РАЗРАБОТКА ПРИЛОЖЕНИЯ В СРЕДЕ DELPHI
    Создание новой программы на Delphi начинается с выбора опции File/New Application. Это означает, что
начинается работа над новым приложением для Windows. В этом случае появляется проект Windowsокна
программы (см. рис. 1). В окне текста программы представлен минимально необходимый код,
обеспечивающий функционирование окна в Windows. Простейшая программа уже готова. Для того чтобы
запустить первую программу, нужно нажать клавишу F9. Эта клавиша соответствует команде Run из
пункта меню Run главного меню Delphi. При выполнении этой команды программа последовательно
проходит три главных этапа своего жизненного цикла  этапы компиляции, компоновки и исполнения. На
этапе компиляции осуществляется преобразование подготовленного текста программы в
последовательность машинных инструкций, на этапе компоновки к ней подключаются необходимые
вспомогательные подпрограммы, а на этапе исполнения готовая программа загружается в оперативную
память и ей передается исполнение.
    Полученная программа ничего не умеет делать, кроме как реагировать на нажатие стандартных кнопок
минимизации, максимизации окна и вывода системного меню. В заголовке полученного окна высветится
имя окна  Form1. По умолчанию заголовок окна совпадает с заголовком формы. Для того чтобы закрыть
работающее приложение, необходимо нажать стандартную кнопку закрытия окна Windows.
    Обратившись к инспектору объектов, можно изменить свойство Caption формы. Caption означает
заголовок. Щелкнув мышью по строке Caption окна инспектора объектов, активизируем эту строку
свойств и в правой колонке запишем новый заголовок "Моя первая программа на Delphi". Новый прогон мышью.
1.
2.
3.
программы создаст окно с заголовком "Моя первая программа на Delphi". С помощью окна инспектора
объектов мы изменили одно из свойств окна программы  его заголовок.
    Процесс создания Delphiпрограммы разбивается на две фазы: фазу конструирования формы и фазу
кодирования.
    Разместим на форме два компонента из панели Standard: метку и кнопку. Для того чтобы поместить
компонент на форму, необходимо выполнить следующие действия:
Выбрать страницу, на которой находится нужный компонент.
Выбрать компонент, который необходимо разместить в форме, щелкнув по нему
Выполнить щелчок мышью в проектировщике формы в том месте, где требуется
данный компонент разместить.
    Компонент Label (метка) предназначен для размещения различного рода надписей. Компонент Label на
панели Standard отражает кнопка . Произведем последовательно два щелчка: по компоненту на панели и
по форме. Теперь форма содержит компонент Label (рис. 8). Новый компонент имеет стандартное имя
Label1 и надпись на нем повторяет это имя. Изменить это имя можно с помощью строки Caption окна
инспектора объектов. Как только вы начнете вводить новую надпись, вид компонента на форме начнет
меняться, динамически отражая все изменения, производимые в окне инспектора объектов.
    Выделим надпись цветом и сделаем ее шрифт более крупным. Для этого необходимо щелкнуть мышью
по свойству Font (шрифт) окна инспектора объектов и открыть в правой части строки диалоговое свойство
настройки шрифта. В этом диалоговом окне можно изменить размер, стиль и цвет шрифта. Надпись на
компоненте в окне формы соответствующим образом изменит свои свойства.
    С помощью обрамляющих черных квадратиков можно изменять размеры компонента. Для этого следует
поместить острие указателя мыши над одним из них (в этот момент указатель меняет свою форму на
двунаправленную стрелку), затем нажать левую кнопку мыши и, не отпуская ее, буксировать сторону или
угол компонента в нужном направлении, после чего отпустить кнопку. Все видимые компоненты имеют
свойства Left (левый), Top (нижний), Width (ширина), Height (высота), числовые значения которых
определяют положение левого верхнего угла компонента и его размеры в пикселях. При буксировании
компонента или изменении его размеров мышью эти значения автоматически меняются. И наоборот
изменение этих свойств в окне инспектора объектов приводит к соответствующему изменению положения
и размеров компонента. В Delphi 4 значения Left и Top автоматически появляются в небольшом окне
рядом с указателем мыши при буксировке компонента по форме.
    Компонент кнопка изображается пиктограммой  на странице Standard палитры компонентов и имеет
название TButton. Первая устанавливаемая кнопка по умолчанию имеет название Button1 (рис. 9).
    При щелчке по кнопке мышью в работающей программе возникает событие OnClick (по щелчку). Чтобы
заставить приложение реагировать на нажатие кнопки, нужно написать на языке Object Pascal фрагмент
программы, который называется обработчиком события. Обработчик события  фрагмент программы,
который выполняется в ответ на определенное изменение в программе или в Windows. Этот фрагмент
должен представлять собой последовательность операторов языка Object Pascal, оформленных в виде
процедуры. В окне инспектора объектов на странице Events следует найти событие OnClick и дважды
щелкнуть мышью по правой части строки. Delphi самостоятельно сделает заготовку для обработчика
события OnClick. Активизируется окно кода с заголовком процедуры и операторными скобками:
    Procedure TForm1.Button1Click(Sender: TObject);
    Begin
    End;
    Процедура имеет составное имя. Оно состоит из имени класса TForm1 и собственно имени процедуры
Button1Click. Процедуры могут иметь параметры.
    Класс в Object Pascal  это дальнейшее развитие объектного типа Турбо Паскаля. Написав обработчик
события, мы добавляем еще один метод к методам, описанным в стандартных классах.
    В тексте процедуры запишем следующий оператор присваивания:
    Label1.Caption := 'Нет, только учусь!';
    Обращение к свойству компонента в программе осуществляется так же, как обращение к полю или к
методу объекта с помощью составного имени.
    Теперь, если запустить программу, то она будет реагировать на нажатие кнопки. Вместо надписи "Я
программирую на Delphi!" появится сообщение "Нет, только учусь!". Текст программы в окне кода программы:
unit Unit1;
interface
uses
Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs;
type
end;
var
TForm1 = class(TForm)
Label1: TLabel;
Button1: TButton;
procedure Button1Click(Sender: TObject);
private
public
{ Private declarations }
{ Public declarations }
Form1: TForm1;
implementation
{$R *.DFM}
procedure TForm1.Button1Click(Sender: TObject);
begin
Label1.Caption := 'Нет, только учусь!';
end;
end.
    Каждый компонент принадлежит к строго определенному классу, а все конкретные экземпляры
компонентов, вставляемые в форму, получают имя класса с добавленным числовым индексом. По
используемому в Delphi соглашению все имена классов начинаются с буквы Т. Таким образом, имя
TForm1 означает имя класса, созданного по образцу стандартного класса TForm.
    Строка
TForm1 = class(TForm)
определяет новый класс TForm1, который порожден от стандартного класса TForm. Строка
Form1 : TForm1;
создает экземпляр этого класса с именем Form1. Стандартный класс TForm описывает пустое Windows
окно, в то время как класс TForm1 описывает окно с уже вставленными в него компонентами метка и
кнопка. Описание этих компонентов содержат строки
Button1: TButton;
Label1: TLabel1;
    Компонент Button1 представляет собой экземпляр стандартного класса TButton, а компонент Label1
экземпляр класса TLabel.
    Параметр процедуры Sender принадлежит классу TObject. Он может использоваться для определения
источника события. В нашем примере он никак не используется. Параметр Sender имеют все обработчики
событий.
Создание прикладных программ, или приложений, в Delphi выполняется в интегрированной среде
разработки IDE (Integrated Development Environment). IDE служит для организации взаимодействия с
программистом и включает в себя ряд окон, содержащих различные элементы управления. С помощью
средств интегрированной среды разработчик может проектировать интерфейсную часть приложения, а
также писать программный код, и связывать его с управляющими элементами. При этом вся работа по
созданию приложения, включая отладку, происходит в IDE.
Главные составные части среды программирования
Интегрированная среда программирования Delphi состоит из следующих основных частей:
1.
Главное окно 2.
3.
4.
5.
Дизайнер форм (Form Designer)
Редактор исходного текста (Editor Window)
Палитра компонентов (Component Palette)
Инспектор объектов (Object Inspector)
В главном окне отображается Главное меню, Панель инструментов и Палитра компонентов (см. рисунок).
Главное меню содержит обширный набор команд для доступа к функциям Delphi. Панель инструментов
находится под Главным меню в левой части Главного окна и содержит 15 кнопок быстрого доступа для
вызова часто используемых команд Главного меню. Палитра компонентов находится справа от Панели
инструментов и содержит множество компонентов, размещаемых в создаваемых приложениях. Все
компоненты делятся на группы, каждая из которых в Палитре компонентов располагается на отдельной
странице (Standard, Additional, Win 32 и др.).
Рисунок  Приложение Delphi.
Дизайнер форм в Delphi служит для создания визуального интерфейса программы (рис. 9). Дизайнер Форм
первоначально состоит из одного пустого окна, которое заполняется компонентами, выбранными в
Палитре компонентов.
Редактор исходного текста (Редактор кода) представляет собой текстовый редактор, с помощью которого
можно создавать и редактировать программный код (рис. 9).
Инспектор объектов состоит из двух страниц, каждую из которых можно использовать для определения
поведения данного компонента (рис. 9). Первая страница – это список свойств, вторая – список событий.
Если нужно изменить чтонибудь, связанное с определенным компонентом, то обычно делается это в
Инспекторе объектов. Страница событий связана с Редактором кода. Если дважды щелкнуть мышкой на
правую сторону какоголибо пункта, то соответствующий данному событию код автоматически запишется
в Редактор. Сам Редактор немедленно получит фокус, и появится возможность добавить код обработчика
данного события.
Организация проекта, основные файлы проекта
Проект в Delphi состоит из форм, модулей, установок параметров проекта, ресурсов и т.д. Вся эта
информация размещена в файлах: файл проекта (.dpr); файл модуля (.pas); описание формы (.dfm);
описание ресурсов (.res); параметры проекта (.dof); параметры среды (.cfg); исполняемый файл (.exe).
Типичная головная программа приложения имеет вид:
program Project1;
uses
Forms,
Unit1 in 'Unit1.pas' {Form1};
{$R *.res}
begin
Application.Initialize;
Application.CreateForm(TForm1, Form1);
Application.Run;
end.
Текст модуля имеет вид.
unit Unit1;
interface
{Список подключаемых модулей}
uses Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
Dialogs; {Объявление класса формы}type
TForm1 = class(TForm)private
{ Private declarations }public { Public declarations }
end;var Form1: TForm1;
{Сюда могут включаться объявления типов, констант, переменных, функций и процедур, к которым будет
доступ из других модулей}
implementation
{$R *.dfm}
{Сюда могут помещаться предложения uses, объявления типов, констант, переменных, к которым не
будет доступа из других модулей. Тут же должны быть реализации всех объявленных в разделе interface
функций и процедур, а также могут быть реализации любых дополнительных, не объявленных ранее
функций и процедур.}
end.

file_name: тема 2 вопрос 25.docx

intro:
В верхней части экрана расположено главное окно (рис. 2). Оно имеет заголовок Delphi 3 - Project1. В строке заголовка главного окна отображается имя открытого в данный момент проекта: Project1. В главном окне находится строка главного меню, панели инструментов и панели компонентов. Главное окно программы остается открытым все время, пока остается загруженной Delphi. Закрыть главное окно - значит закончить работу с системой программирования.
    Строка меню содержит команды, необходимые для разработки и тестирования приложений, а также управления ими.
    Панель инструментов (рис. 3) содержит кнопки, которые соответствуют определенным командам меню, например командам File, View и др. Щелчок на какой-либо из кнопок приводит к тому же результату, что и выбор соответствующей команды в главном меню.

title: Лекция "ИНТЕГРИРОВАННой СРЕДы РАЗРАБОТКИ "