Методы проектирования структуры ПО

Как только определен класс (тип), например, с именем А, можно говорить об объектах этого класса (переменных типа А), которые  называют также экземплярами класса. Раздел атрибутов предназначен для  объявления переменных класса (данных). Раздел операций предназначен для объявления и определения операций, которые  можно выполнять над объектами  класса, или иначе, методов класса. Методы описывают поведение объектов класса в результате выполнения операций. 
По умолчанию все члены класса считаются закрытыми и доступ к ним могут получить только функции-члены этого класса. Если необходимо изменить тип доступа к членам класса, перед ними следует указать один из спецификаторов доступа public, protected или private. 
Чтобы скрыть реализацию операций, определение класса разбивается на две части: интерфейс класса и реализацию класса. Интерфейс класса содержит только объявление его элементов: переменных и методов. Определения методов в виде их реализации отделены от интерфейса и помещаются в реализацию класса. Достоинство этой схемы в том, что программист может использовать класс, зная его интерфейс, и не вдаваясь в детали реализации (вспомним один из принципов Хольта, где утверждалось, что модуль легче использовать, чем разработать! Для классов этот принцип справедлив вдвойне). Из интерфейса можно понять, какие в классе операции, как их вызывать, какова их семантика. Реализация операций может быть произвольной, лишь бы она соответствовала семантике. Изменение реализации при сохранении интерфейса и семантики не влияет на программы, использующие данный класс. Признаком хорошего стиля считается полное сокрытие данных (переменных класса) с помощью спецификаторов private и protected, означающее, что доступ к ним возможен только посредством методов данного класса или его наследников, а непосредственный доступ к ним запрещен.

4.2. Структура программы.

Ниже  приведен пример описания структуры (слева) и класса (справа) на языке С++. В  нем создается тип данных (класс)  degree. Закрытая переменная-член  data_value доступна только функциям-членам класса. Одновременно создается и объект данного класса – переменная deg. 
//     trigon.cpp  
// в программе создается структура, содержащая  
// тригонометрические функции 
#include <iostream.h> 
#include <math.h>

const double  DEG_TO_RAD = 0.0174532925; 
struct degree {                                                                          class degree { 
     double data_value;                                                              struct degree { 
   void set_value(double angle);                                               double data_value; 
                                                                                                 public: 
                                                                                                      void set_value(double); 
double get_sine(void);                                                              double get_sine(void); 
double get_cosine(void);                                                          double get_cosine(void); 
double get_tangent(void);                                                         double get_tangent(void); 
double get_cotangent(void);                                                     double get_cotangent(void); 
double get_secant(void);                                                           double get_secant(void); 
double get_cosecant(void);                                                       double get_cosecant(void); 
} deg;                                                                                         } deg;

void degree:: set_value(double angle)                                      void degree:: set_value(double angle) 
{                                                                                                   { 
   data_value = angle;                                                                    data_value = angle; 
}                                                                                                    } 
double degree::get_sine(void)                                                      double degree::get_sine(void) 
{                                                                                                    { 
 return (sin(DEG_TO_RAD * data_value));                                    return (sin(DEG_TO_RAD * data_value)); 
}                                                                                                    } 
double degree::get_cosine(void)                                                    double degree::get_cosine(void) 
{                                                                                                     { 
  return (cos(DEG_TO_RAD * data_value));                                    return (cos(DEG_TO_RAD * data_value)); 
}                                                                                                        } 
double degree::get_tangent(void)                                                    double degree::get_tangent(void) 
{                                                                                                        { 
  return (tan(DEG_TO_RAD * data_value));                                     return (tan(DEG_TO_RAD * data_value)); 
}                                                                                                       } 
double degree::get_cotangent(void)                                               double degree::get_cotangent(void) 
{                                                                                                       { 
  return (1.0 / tan(DEG_TO_RAD * data_value));                            return (1.0 / tan(DEG_TO_RAD * data_value)); 
}                                                                                                        } 
double degree::get_secant(void)                                                      double degree::get_secant(void) 
{                                                                                                       { 
   return (1.0 / sin(DEG_TO_RAD * data_value));                             return (1.0 / sin(DEG_TO_RAD * data_value)); 
}                                                                                                        } 
double degree::get_cosecant(void)                                                   double degree::get_cosecant(void) 
{                                                                                                        { 
  return (1.0 / cos(DEG_TO_RAD * data_value));                          return (1.0 / cos(DEG_TO_RAD * data_value)); 
}                                                                                                         } 
main () 
{ 
//   устанавливаем угол = 25 градусов  
get set_value(25.0); 
cout << “ синус угла равен ” << deg.get_sine()                             cout << “ косеканс угла равен ” << deg.get_ cosecant () 
        << end1;                                                                                           << end1; 
cout << “ косинус угла равен ” << deg.get_cosine()                      return(0); 
        << end1;                                                                                     } 
cout << “ таненс угла равен ” << deg.get_ tangent() 
        << end1; 
cout << “ котангенс угла равен” << deg.get_ cotangent () 
        << end1; 
cout << “ секанс угла равен ” << deg.get_ secant () 
        << end1;

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

Отношение наследования обычно представляют в  виде графа, узлы которого соответствуют  классам, и из узла А в узел В  ведет дуга, если класс В является непосредственным наследником класса А. Этот граф изображает иерархию классов  с точки зрения наследования. Если наследование единичное (иерархическое), соответствующий класс является деревом. В корне дерева находится  прародитель - класс, для которого все  остальные классы являются потомками. На рис.4.1,а в виде графа представлена иерархия единичного наследования классов, а на рис.4.1,б представлен реальный пример – дерево каталогов диска С. 
Под множественным наследованием понимается способность наследования свойств (атрибуты и операции) и поведения не от одного базового класса, а от нескольких. Свойства класса-предка, встречающегося более чем один раз, в графе наследования указываются только в одном экземпляре. 
Производный класс расширяет свойства и поведение базового класса. В производном классе можно: 
• объявить новые переменные с любыми правами доступа; 
• объявить новые методы с любыми правами доступа; 
• переопределить (перекрыть) методы базового класса. 
Переопределение метода класса А в производном классе В - это определение в классе В метода с именем, которое уже является именем некоторого метода в классе А. Обычно переопределение осуществляется для того, чтобы привести поведение объектов класса в соответствие с их изменившимся состоянием. 
Наконец, еще один важный принцип, применяемый в объектно-ориентированных языках, - автоматическая сборка мусора в динамической памяти. Согласно этому принципу, программист явно только "порождает" объекты, но никогда не заботится об их уничтожении. Это существенно повышает надежность программ и эффективность использования памяти, поскольку исключает слишком раннее и слишком позднее "уничтожение" объектов. 
Процедура объекта может быть вызвана без ссылки на ее точное представление, поскольку каждый объект может быть экземпляром многих производных классов. Это проясняет, почему вместо термина «вызов процедуры» используется термин «отправка сообщения»: ведь значение сообщения известно, а интерпретирующая процедура — нет.

4.3. Типы данных.

 
Идентификаторы.  Типизированные константы. Переменные. Строки. 
Идентификаторы 
Имена, которые присваиваются константам, типам данных,  переменным и функциям называются идентификаторами.  
Правила  создания  идентификаторов: 

• должны  начинаться с буквы (a...z,A...Z)  или  с  подчеркивания  (_),
• остальная часть идентификатора должна состоять из  букв,  подчеркиваний и/или цифр(0...9).

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

• целые, 
• с  плавающей  запятой,
• символьные константы,
• строки.

Константы представляются в виде  целого десятичного, восьмиричного или шестнадцатиричного числа. 
Описание констант начинается с  ключевого  слова  const,  далее тип и значение, например const int Nalog=2.

Переменные 
Переменная - это поименованная величина, значение  которой может изменяться во время выполнения  программы. Переменная принадлежит к определенному типу. 
Целые типы. 
Целые числа представляются целыми типами. Целый тип - это обобщенный  тип, представление которого зависит от операционной системы и типа процессора. 
Рассмотрим основные типы целых чисел:

• Short int                    16 битовое целое
• Int                               16 битовое целое
• Unsigned long           32 битовое целое без знака
• Long                           32 битовое целое

Пример  по объявлению одной константы и  двух переменных  целого типа: 
#include “stdio.h” 
#include “conio.h” 
main() 
{ 
                      const int Nalog= 2; 
                      int      Stavka; 
                      int      Symma; 
                      int C; 
            Stavka = 300; 
            Symma = Stavka * Nalog; 
            printf("Symma naloga = %d\\n",Symma); 
            C=getch(); 
} 

Вещественные типы

Для хранения чисел с дробной  частью  используется  вещественный тип: 
Float                 32 битовое плавающее число 
Double             64 битовое плавающее число 
Long double    80 битовое плавающее число

Пример, где вещественный тип представлен  переменной Symma: 
#include “stdio.h” 
main() 
{ 
                          const float Nalog= 0.7; 
                          int Stavka; 
                          float Symma; 
            Stavka = 325; 
            Symma = Stavka * Nalog; 
            printf("Symma naloga = %8.4f\\n",Symma); 
} 
Символьные типы 
Символьный тип -Char  предназначен  для  хранения  одного символа, поэтому его размер - один  байт.  
Unsigner char           8 бит без знака 
Char                           8 бит

Пример, где переменной A присвоено значение ‘D’, переменной B значение  ‘!’, а переменной С присвоено значение  символа  ‘*’: 
#include <stdio.h> 
main() 
{ 
            char         A; 
            char         B; 
            char         C; 
            A = \'D\'; 
            B = \'!\'; 
            printf("A= %c B= %c\\n",A,B); 
            C = \'*\'; 
            printf("C= %c\\n",C); 
}

Тип данных строка

Для представления строки символов используются  массивы типа char. 
Пример, где представлены три строки символов A, B, C: 
#include <stdio.h> 
#include <string.h> 
main() 
{ 
            char         A[256];   /* длина может быть до 256 символов */ 
            char         B[11]; 
            char         C[24]; 
            strcpy(A,"IBM PC Pentium"); 
            strcpy(B,"Windows 95"); 
            strcpy(C,"");   /* очистка переменной */ printf("A= %s\\n",A); 
            printf("B= %s\\n",B); 
            strcpy(C,B); 
            printf("C= %s\\n",C); 
}

По  команде, например, strcpy (A,"IBM PC Pentium"); в строку A помещается текст IBM PC Pentium. 
Кроме рассмотренного примера, для определения  строк  можно использовать указатель на символы. Пример:

#include <stdio.h> 
#include <string.h> 
main() 
{ 
            char *msg; 
            msg = "Привет, студент"; 
            puts(msg); 
}

Звездочка перед msg означает, что msg является  указателем на символ - т.е. msg может хранить адрес символа. Однако, при этом память для размещения символов  не выделяется. 
Команда msg = "Привет, студент  "  присваивает  начальный адрес этой строки - (адрес символа П) переменной msg. Команда puts(msg)  печатает символы до тех пор, пока она  не встретит нулевой символ, обозначающий конец строки..

Структуры 
Размещенная в памяти совокупность связанных  между  собой данных представляет структуру.  
Виды структур:

• массивы,
• записи
• их комбинации.

Массивы 
Именованная совокупность однородных данных называется массивом. Каждый элемент массива хранится в  отдельной  области памяти и имеет собственный номер (начиная с нуля). 
Пример. 
#include <stdio.h> 
main() 
{ 
            int B[3]; 
            B[0] = 0; 
            B[1] = 10; B[2] = 20; B[3] = 30; 
            printf("B[0]= %d\\n",B[0]); 
            printf("B[1]= %d\\n",B[1]); 
            printf("B[2]= %d\\n",B[2]); 
            printf("B[3]= %d\\n",B[3]); 
}