Измерения и анализ Измерение 1. Выполнение измерений и использование их результатов для определения статуса мероприятий по разработке и усовершенствованию производственного процесса организации.Примеры измерений:определение объема выполненных работ по оценке,

Компиляция

Рис. 2.5. Компиляция плюс интерпретация

Виртуальные машины, байт-код и JIT (Just In Time )

Реализация таких языков, как Java, C# и других языков платформы.NET, основана на смешанном решении. Промежуточный код для Java называется байт-кодом. В этом термине отображается тот факт, что виртуальная машина использует компактные команды, подобные командам фактического процессора. Для повышения эффективности времени выполнения байт-кода применяют JIT (Just In Time) компиляторы, называемые джитерами , осуществляющие компиляцию по требованию. Основная идея состоит в том, что машинный код для некоторого модуля создаётся «на лету», в тот момент, когда он первый раз вызывается на выполнение. Последовательность обработки программы можно представить следующей схемой.

Исходная программа

Компилятор

Компиляция

Интерпретатор

Выполнение

Машинный код

Рис. 2.6. Компиляция плюс интерпретация и джитинг

Четвертую группу базового программного обеспечения образуют программы технического обслуживания компьютера . К множеству таких программ, например, относятся программы диагностики и обнаружения ошибок в процессе работы локального компьютера или сети.

2.1. Проверка достижения целей

2.2.Правильные ответы

3. Структура программ и правила их кодирования

Цели

Изучив данный учебный элемент, вы будете способны:

правильно трактовать виды и назначение единиц трансляции;

распознавать структуру программы;

правильно трактовать определение функции;

выделять структурные составляющие определения функции;

распознавать объявления внешних объектов.

3.1. Общие сведения

Программа – это алгоритм, записанный на понятном для исполнителя языке. Для компьютера алгоритм должен записываться на языке программирования. Запись алгоритма на языке программирования называется кодированием. При кодировании на языке программирования высокого уровня исходный код программы записывается отдельными предложениями. Обычно такими предложениями являются:

комментарии,

определения и объявления,

операторы.

Комментарии – это пояснения для человека, который будет просматривать текст программы. Для выполнения действий, предусмотренных данным алгоритмом, этот вид предложений не нужен. Эти предложения могут быть полезными только на этапе просмотра программы человеком.

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

Чтобы транслятор смог выполнить свои функции, ему нужно предоставить сведения о данном объекте и потребовать его создания, если объект ещё не создан. Под созданием объекта понимают выделение для него блока памяти и связывание адреса этого блока с именем объекта. После создания объекта его имя является условным обозначением адреса блока памяти объекта. Требование создания объекта программист указывает в форме определения.

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

Таким образом, тип Integer описывает значения, которые представлены целыми (т.е. без дробной части) числами, Double – множество значений, представленных числами с дробной частью, Char – символьные значения, Boolean – логические значения, а String – строки символов, т.е. некоторую последовательность символов.

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

В языках C++ и C# определения записываются предложениями, которые могут последовательно располагаться на одной строке или на отдельных строках. В Visual Basic они записываются только на отдельных строках теста программы. В любом из представленных языков разрешено в одном определении можно указывать имя одиночного объекта или список имён. Такие предложения формируются по следующим шаблонам:

Язык С++:

<тип > <Имя объекта >;

<тип > <Список имён объектов >;

Язык С#:

<тип > <Имя объекта >;

<тип > <Список имён объектов >;

var <Имя объекта >=<Инициализатор >;

Язык Visual Basic :

Dim <Имя объекта > As <Имя типа >

Dim <Список имён объектов > As <Имя типа >

Dim <Имя объекта >=<Инициализатор >

Например, конструкции

Язык Visual Basic : Язык С ++: Язык С#:

Dim m As Integer int m; int m;

Dim n1, n2 As Integer int n1, n2; int n1, n2;

Dim x, w, z As Double; double x, w, z; double x, w, z;

Dim box=56 var box=56;

являются определением целочисленного объекта (переменной) m, двух целочисленных переменных n1, n2 и трёх вещественных переменных x, w, z, соответственно.

На заметку! В языках C ++, C # определения записываются в любой позиции среди других предложений и завершаются точкой с запятой. В Visual Basic каждое определение точку с запятой не содержит и записывается на отдельной строке или в одной строке через двоеточие. В любом случае определения всегда должны предшествовать позициям, в которых указано использования объектов.

Непосредственно после создания объект не содержит полезного для программиста значения. Такое значение программист должен задавать ему самостоятельно. Для выполнения такого действия используют операции инициализации, присваивания и ввода.

Операция инициализации – это копирование значения сразу же после выделения памяти. Она указывается непосредственно в определении объекта с помощью символа = (равно). Выглядит это следующим образом:

Язык Visual Basic : Язык С ++: Язык С#:

Dim a As Integer=60; int a=60; или int a(60); int a=60;

Dim b=700 var b=700;

В данном случае переменная A инициализирована значением 60.

Операция присваивания указывается в любой момент и в нужной позиции текста программы после определения объекта. В простейшем случае присваивание также указывается символом равно (=). Например, для задания значения 35 целочисленной переменной mom задают операцию

Язык Visual Basic : Язык С ++: Язык С#:

mom = 35 mom=35 mom=35

Операция ввод а предполагает копирование значения от внешнего источника. Каждый язык может иметь собственный набор средств для кодирования ввода данных.

В Visual Basic ввод данных с клавиатуры можно кодировать с помощью блоков диалога или методов классов Console. Например, представленная ниже программа иллюстрирует возможности ввода данных с помощью блока диалога InputBox() и метода Console.ReadLine().

Листинг 3.1.1.

" Иллюстрация ввода и вывода разными средствами

Dim userName As String = InputBox("Как вас зовут?")

MsgBox("Имя пользователя: " & userName)

Console.Write("Введите имя пользователя: ") : userName = Console.ReadLine()

Console.WriteLine("Имя пользователя: {0}", userName)

Console.ReadKey()

Не забывайте, что методы класса – это просто функции, которые определены внутри соответствующего класса. Для обращения к методу класса указывают имя класса, точку и имя метода с круглыми скобками, которые могут быть пустыми или содержать список аргументов. Обычно при работе с консольным окном для кодирования ввода с клавиатуры вы будете вызывать методы Console.ReadLine() и Console.Read(). Первый из этих методов считывает строку символов, а второй – внутренний код одиночного символа. В вызовах методов внутри круглых скобок не указывают никаких аргументов , считанные данные поступают в точку вызова методов. При использовании разных средств ввода данных нужно помнить, что вызов блока ввода InputBox() приводит к отображению блока диалога с однострочным редакторов, в строку которого пользователь вводит нужные ему данные. Например, для данной программы отображается блок диалога, вид которого после ввода имени «Волобуев» представлен на рис. 3.1.1.

Рис. 3.1.1. Вид блока диалога ввода после ввода в строку редактора имени пользователя

Поскольку метод Console.ReadLine() возвращает строку символов, которая может представлять текст или образ числа, то для получения самого числа нужно явно указывать преобразование текстового образа в число. Для этой цели в VB используются методы класса Convert или собственные макросы вида CInt(), CDbl() и т.п.. Метод с именем ToInt32(s) или макрос CInt(s) вызывают для преобразования строки символов в целое число, а метод ToDouble(s) или макрос CDbl(s) – в вещественное число удвоенной точности. В конкретном случае ввод целого и вещественного числа и преобразование к числовому типу с помощью методов класса Convert выглядит следующим образом:

Dim mm As Integer= Convert.ToInt32(Console.ReadLine())

Dim m1 As Double = Convert.ToDouble(Console.ReadLine())

Dim box= Convert.ToDouble(Console.ReadLine())

Если использовать макросы, то эти дже операторы приобретают вид

Dim mm As Integer= CInt(Console.ReadLine())

Dim m1 As Double = CDbl(Console.ReadLine())

Dim box= CDbl(Console.ReadLine())

Пример .

Написать консольное приложение для вычисления площади прямоугольника, задаваемого длинами своих сторон. Длины сторон вводятся с клавиатуры.

Ответ (Листинг 3.1.2).

Листинг 3.1.2.

" Вычисление площади прямоугольника

Console.Write("Введите длину строны A прямоугольника: ")

Dim a As Double = Convert.ToDouble(Console.ReadLine())

Console.Write("Введите длину строны B прямоугольника: ")

Dim b As Double = Convert.ToDouble(Console.ReadLine())

Console.WriteLine("Площадь прямоугольника: {0}", a * b)

Console.ReadKey()

После активизации приложения отображается диалог, показанный на рис. 3.1.2.

Рис. 3.1.2. Возможная форма диалога, отображаемого в консольном окне

В C # ввод с клавиатуры кодируется методами Console.ReadLine() и Console.Read(). Они могут вызывается в той же форме, которая описана для VB, но для преобразования к числовому типу можно обычно использовать только средства класса Convert. Например, если записать

int a, b, mm = Convert.ToInt32(Console.ReadLine());

double m1 = Convert.ToDouble(Console.ReadLine());

a=Convert.ToInt32(Console.ReadLine());

b=Convert.ToInt32(Console.ReadLine());

Операция ввода может указываться не обязательно в сочетании с именем объекта. Например, если активизировать приложение, в форме листинга 3.1.3

Листинг 3.1.3.

namespace ConsAppSharp00 {

class Program {

Console.Title = "Ввод данных";

Console.WriteLine("Введите a, b."); // Заголовок консольного окна

var a=Convert.ToInt32(Console.ReadLine());

Console.WriteLine("a={0} b={1}",a, Convert.ToInt32(Console.ReadLine()));

Console.ReadKey();

то консольное окно будет иметь состояние, представленное на рис. 3.1.3.

Рис. 3.1.3. Итоговое состояние консольного окна

В C ++ ISO / ANSI операция ввода с клавиатуры кодируется операцией извлечения из потока cin , записываемой символом ‘>>’. Например, если записать

int mm; cin>>mm;

double m1; cin>>m1;

int a, b; cin>>a>>b;

то это будет означать ввод значений переменных mm, m1, a и b с клавиатуры.

В C ++/ CLI операция ввода с клавиатуры кодируется методами класса Console точно так же, как в C# или с помощью потока cin и операции ‘>>’. Например, если записать

int mm = Convert::ToInt32(Console::ReadLine());

double m1 = Convert::ToDouble(Console::ReadLine());

a=Convert::ToInt32(Console::ReadLine());

b=Convert::ToInt32(Console::ReadLine());

int mm; cin>>mm;

double m1; cin>>m1;

int a, b; cin>>a>>b;

то это будет означать ввод значений переменных mm, m1, a и b с клавиатуры. Подобно C#, операция ввода с помощью вызовов методов класса Console может указываться не обязательно в сочетании с именем объекта. Например, если активизировать приложение, в форме листинга 3.1.4

Листинг 3.1.4.

// qq.cpp: главный файл проекта.

// Пример использования операции ввода

#include "stdafx.h"

using namespace System;

int main(array ^args) {

Console::Title = L"Ввод данных";

Console::WriteLine(L"Введите a, b."); // Заголовок консольного окна

int a=Convert::ToInt32(Console::ReadLine());

Console::WriteLine(L"a={0} b={1}",a, Convert::ToInt32(Console::ReadLine()));

Console::ReadKey();

Итог выполнения данного приложения будет иметь такую же форму, которая указана на рис. 3.1.3.

Операция вывод а. Значения объектов можно не только задавать, но и отображать на экране. Каждый язык программирования может иметь собственный набор средств кодирования этой операции. Однако для языков, поддерживающих платформу.NET, вывод в консольное окно может кодироваться вызовами методов класса Console. К такому множеству языков относятся VB, C# и C++/CLI. В C++ ISO/ANSI вывод в консольное окно можно реализовать операцией вставки в поток cout, которая указывается символом ‘<<’.

В среде VB для вывода можно использовать как блоки диалога, так и средства класса Console. К множеству блоков вывода сообщений относится, например, блок с именем MsgBox(). Этот блок имеет несколько модификаций. В простейшем случае он может содержать внутри скобок одну строку символов, представляющую отображаемое сообщение. Например, для отображения текста «Это моя первая программа.» достаточно указать вызов этого блока в форме

MsgBox("Это моя первая программа. ")

Если же сообщение состоит из нескольких частей, то части можно сцеплять с помощью символа амперсанда (&) в единую строку символов. Например, в представленной выше программе введённое имя пользователя сцепляется со строкой "Имя пользователя: ".

После вызова такого блока диалога на экране отображается блок диалога, вид которого представлен на рис. 3.1.4.

Рис. 3.1.4. Вид блока диалога вывода сообщения об имени пользователя

Для вывода данных в консольное окно средствами.NET вызывают методы Console.WriteLine(]) и Console.Write(s[, list_elem]), которые отображают строку символов, представленную первым параметром s. Второй параметр – это список элементов, используемых для модификации первого параметра непосредственно перед его отображением. Квадратные скобки в данном случае – это условное обозначение того, что эти параметры могут опускаться. В простейших ситуациях в круглых скобках можно указывать текст в кавычках или конкретное одиночное значение или имя одной переменной или выражение.. Например, операторы

Console.WriteLine("Объём контейнера")

Console.Write("Стоимость работ: ")

Console.WriteLine(235)

Console.Write(67+33)

Аналогично, любой вызов методов Console.ReadLine(), Console.Read() предполагает, что ввод данных сопровождается их автоматическим отображением в консольном окне. Например, диалог ввода данных в программе, представленной листингом 3.1.1, отображается в консольном окне в форме, которая представлена на рис. 3.1.5.

Рис. 3.1.5. Состояние консольного окна после ввода имени пользователя

В C # и C ++/ CLI операция вывода в консольное окно указывается аналогично. Если операция записывается в форме отдельного оператора, то вызов метода завершается точкой с запятой. Например, в среде C # операторы

Console.WriteLine("Объём контейнера");

Console.Write("Стоимость работ: ");

отображают в консольном окне текст, который указан между кавычками. А операторы

Console.WriteLine(235);

Console.Write(67+33);

обеспечивают отображение числа 235 и 100, соответственно.

Аналогичные операторы для среды C ++/ CLI имеют вид:

Console::WriteLine(L"Объём контейнера");

Console::Write(L"Стоимость работ: ");

Console::WriteLine(235);

Console::Write(67+33);

Например, вот как может выглядеть приложение C# для ввода значений с клавиатуры и отображения значений в консольном окне.

Листинг 3.1.5.

// Иллюстрация кодирования ввода/вывода в консольное окно

// Программист А. Ф.

namespace AppSh100 {

class Program {

static void Main(string args) {

Console.WriteLine("Введите целое и вещественное число."); // Подсказка о вводе

int mm = Convert.ToInt32(Console.ReadLine()); // Ввод целого числа

double valueCap = Convert.ToDouble(Console.ReadLine()); // Ввод вещественного числа

Console.WriteLine("Сумма чисело=: {0}", mm + valueCap); // Вывод суммы чисел

Console.ReadKey(); // Пауза для просмотра итога

После активизации приложения и ввода чисел 50 и 25,5 состояние консольного окна может быть таким, как показано ра рис. 3.1.6.

Рис. 3.1.6. Итоговое состояние консольного окна

Простейшее приложение C++/CLI может иметь следующий вид:

Листинг 3.1.6.

// Программист А. Ф.

#include "stdafx.h" // Сохраните в своем проекте это подключение

using namespace System; // Объявление пространства имен

int main(array ^args) {

// Ввод в режиме диалога значений А и В

Console::WriteLine(L"Введите А, В: ");

double a = Convert::ToDouble(Console::ReadLine());

double b = Convert::ToDouble(Console::ReadLine());

double y = Math::Sin(a+b); // Определение переменной y

// Вывод итога в консольное окно

Console::WriteLine(L"Y= {0}", y);

После активизации такой программы диалог с пользователем может иметь показанный на рис. 3.1.7 вид:

Рис. 3.1.7. Форма диалога, генерируемого приложением

В C ++ ISO / ANSI вывод в консольное окно кодируется операцией вставки в поток cout. Например, представленные выше операторы могут записываться в форме

cout<<"Объём контейнера"<

cout<<"Стоимость работ: ";

cout<<(67+33);

Примером кодирования простейшего приложения является следующая программа:

Листинг 3.1.7.

/* Вычисление значения выражения */

#include "stdafx.h" // Всегда сохраняйте в своем проекте это подключение

#include // Для доступа к функции Sin(x)

#include // Подключение средств ввода/вывода

using namespace std; // Объявление пространства имён std

int _tmain(int argc, _TCHAR* argv){

double a, b; // Определение вещественных переменных a, b

setlocale(LC_CTYPE, "Russian"); // Настройуа вывода на кириллицу

cout<<"Введите A, B: "; cin >>a >> b; // Ввод с клавиатуры

cin.get(); // Для считывания завершающего нажатия Enter

/* Вычисление значения и вывод на экран */

double y = sin(a+b); // Определение вещественной переменной y

cout << "\nY= " <

cin.get(); // Пауза для просмотра итога

При формировании текста этой программы многострочными комментариями указано назначение программы и выделен этап вычисления и вывода значения на экран. Все остальные комментарии однострочные. После активизации такой программы диалог с пользователем может иметь показанный на рис 3.1.8 вид.

Рис. 3.1.8. Итоговый вид консольного окна приложения

Единица трансляции . Языки программирования C++, C# и Visual Basic 2010 являются языками высокого уровня. Это означает, что любая записанная с их помощью программа обязательно должна транслироваться. Единицей трансляции для них является файл . Из этого вытекает, что программа на этих языках может представляться одним или несколькими файлами исходного кода, каждый из которых должен подаваться на вход транслятора. Любой файл, содержащий исходный код всей программы или её части, может включать в себя последовательность определений интерфейсов, классов, делегатов и структур. Для VB файл может содержать модули. Внутри каждого модуля вы можете объявлять и определять типы, постоянные, переменные и подпрограммы. Для C++ файл может также содержать набор функций, границы которых не пересекаются.

Напоминание!

Структуры – типы, которые являются упрощёнными вариантами классов.

Делегаты - специальные классы, предназначенные для описания объектов, способ-ных стать средством вызова связанных с ними методов.

Интерфейсы – специальная разновидность абстрактных классов, которые формально описывают заголовки средств доступа к ресурсам, а тип перечисляемых предназначен для описания объектов, значения которых перечисляются программистом при описании типа.

3.2. Структура программы и подпрограммы

Программа Visual Basic построена из стандартных блоков – решений, проектов, сборок, исходных файлов, модулей, классов и интерфейсов. Решение состоит из одного или нескольких проектов. Проект, в свою очередь, может содержать одну или несколько сборок. Каждая сборка компилируется из одного или нескольких исходных файлов. Исходный файл включает в себя определения и реализацию классов, структур, модулей и интерфейсов, и, в конечном счёте, содержит весь код.

Лексический анализ – это процесс сканирования потока входных символов и разделения его на строки, называемые лексемами. Большинство книг по компиляторам начинаются с этого и посвящают несколько глав обсуждению различных методов построения сканеров.

Такой подход имеет свое место, но, как вы уже видели, существуют множество вещей, которые вы можете сделать даже никогда не обращавшись к этому вопросу, и, фактически, сканер, который мы здесь закончим, не очень будет напоминать то, что эти тексты описывают. Причина? Теория компиляторов и, следовательно, программы следующие из нее, должны работать с большинством общих правил синтаксического анализа. Мы же не делаем этого. В реальном мире возможно определить синтаксис языка таким образом, что будет достаточно довольно простого сканера. И как всегда KISS – наш девиз.

Как правило, лексический анализатор создается как отдельная часть компилятора, так что синтаксический анализатор по существу видит только поток входных лексем. Теоретически нет необходимости отделять эту функцию от остальной части синтаксического анализатора. Имеется только один набор синтаксических уравнений, который определяет весь язык, поэтому теоретически мы могли бы написать весь анализатор в одном модуле.

Зачем необходимо разделение? Ответ имеет и теоретическую и практическую основы.

В 1956 Ноам Хомский определил «Иерархию Хомского» для грамматик. Вот они:

Тип 0. Неограниченные (например Английский язык)

Тип 1. Контекстно-зависимые

Тип 2. Контекстно-свободные

Тип 3. Регулярные.

Некоторые характеристики типичных языков программирования (особенно старых, таких как Фортран) относят их к Типу 1, но большая часть всех современных языков программирования может быть описана с использованием только двух последних типов и с ними мы и будем здесь работать.

Хорошая сторона этих двух типов в том, что существуют очень специфические пути для их анализа. Было показано, что любая регулярная грамматика может быть анализирована с использованием частной формы абстрактной машины, называемой конечным автоматом. Мы уже реализовывали конечные автоматы в некоторых их наших распознающих программ.

Аналогично грамматики Типа 2 (контекстно-свободные) всегда могут быть анализированы с использованием магазинного автомата (конечный автомат, дополненный стеком). Мы также реализовывали эти машины. Вместо реализации явного стека для выполнения работы мы положились на встроенный стек связанный с рекурсивным кодированием и это фактически является предочтительным способом для нисходящего синтаксического анализа.

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

Так как требуется различные виды абстрактных машин для анализа этих двух типов грамматик, есть смысл отделить эти низкоуровневые функции в отдельный модуль, лексический анализатор, который строится на идее конечного автомата. Идея состоит в том, чтобы использовать самый простой метод синтаксического анализа, необходимый для работы.

Имеется другая, более практическая причина для отделения сканера от синтаксического анализатора. Мы хотим думать о входном исходном файле как потоке символов, которые мы обрабатываем справа налево без возвратов. На практике это невозможно. Почти каждый язык имеет некоторые ключевые слова типа IF, WHILE и END. Как я упомянул ранее, в действительности мы не можем знать является ли данная строка ключевым словом до тех пор пока мы не достигнем ее конца, что определено пробелом или другим разделителем. Так что мы должны хранить строку достаточно долго для того, чтобы выяснить имеем мы ключевое слово или нет. Это ограниченная форма перебора с возвратом.

Поэтому структура стандартного компилятора включает разбиение функций низкоуровневого и высокоуровневого синтаксического анализа. Лексический анализатор работает на символьном уровне собирая символы в строки и т.п., и передавая их синтаксическому анализатору как неделимые лексемы. Также считается нормальным позволить сканеру выполнять работу по идентификации ключевых слов.