Простые типы 9 страница

был только один список объявлений:
class С {
public:
private:
public:
private:
};
Объявления в общей части доступны любым модулям, использующим этот
класс, в то время как объявления в закрытой части доступны только внутри
класса. Спецификатор const в get_airplane — это следующее средство управ-
ления, он означает, что подпрограмма не изменяет никакие данные внутри
объекта класса. Такие подпрограммы называются инспекторами (inspectors).
Поскольку класс является типом, могут быть объявлены объекты (кон-
станты и переменные) этого класса, так называемые экземпляры класса:
Airplanes Airplane; // Экземпляр класса Airplanes
int index;
Airpianes::Airplane_Data a;
Airplane.new_airplane(a, index); // Вызов подпрограммы для экземпляра
Классом может быть и тип параметра. Для каждого экземпляра будет выделе-
на память всем переменным, объявленным в классе, точно так же, как для пе-
ременной типа запись выделяется память всем полям.
Синтаксис вызова подпрограммы отличается от синтаксиса, принятого в
языке Ada, из-за различий в исходных концепциях. Вызов в языке Ada:
Airplane_Package.New_Airplane(Airplane, A, Index);
рассматривает пакет как применение ресурса — процедуры New_Airplane, ко-
торой должен быть задан конкретный объект Airplane. Язык C++ полагает,
что объект Airplane — это экземпляр класса Airplanes, и, если вы посылаете
объекту сообщение (message) new_airplane, для этого объекта будет выполнена
соответствующая процедура.
Обратите внимание, что даже такие подпрограммы, как find_empty_entry,
которые используются только внутри класса, объявлены в определении
класса. Язык C++ не имеет ничего похожего на тело пакета, представляющее собой единицу, которая инкапсулирует реализацию интерфейса и других подпрограмм. Конечно, внутренняя подпрограмма недоступна другим модулям, потому что она объявлена внутри закрытой части. И языке
C++ проблема состоит в том, что, если необходимо изменить объявление
find_empty_entry или добавить другую приватную подпрограмму, придется
перекомпилировать все модули программы, которые используют этот класс;
в языке Ada изменение тела пакета не воздействует на остальную часть программы. Чтобы достичь на языке C++ реального разделения интерфейса и реализации, следует объявить интерфейс как абстрактный класс, а затем
получить конкретный производный класс, который содержит реализацию.
Где находятся подпрограммы реализованного класса? Ответ состоит в том,
что они могут быть реализованы где угодно, в частности в отдельном файле,
который обращается к определению класса через включаемый файл. Операция разрешения контекста «::» идентифицирует каждую подпрограмму как принадлежащую конкретному классу:

// Некоторый файл
#include "Airplanes.h" // Содержит объявление класса

void Airplanes::new_airplane(const Airplane_Data & a, int & i)

{

}

void Airplanes::get_airplane(int i, Airplane_Data & a) const

{

}

int Airplanes::find_empty_entry()

{

}

Обратите внимание, что внутренняя подпрограмма find_empty_entry должна
быть объявлена внутри (в закрытой части) класса так, чтобы она могла обра-
щаться к приватным данным.

Пространство имен
Одним из последних добавлений к определению языка C++ была конструк-
ция namespace (пространство имен), которая дает возможность программи-
сту ограничить область действия других глобальных объектов так же, как это
делается с помощью пакета в языке Ada. Конструкция, аналогичная use-пред-
ложению в Ada, открывает пространство имен:
namespace N1 {
void proc(); // Процедура в пространстве имен
};
namespace N2 {
void proc(); // Другая процедура
};
N1:: proc(), //Операция разрешения контекста для доступа
using namespace N1;
proc(); // Правильно
using namespace N2;
proc(); // Теперь неоднозначно
К сожалению, в языке C++ не определен библиотечный механизм: объявления класса могут использоваться совместно только через включаемые файлы.
Группа разработчиков должна организовать процедуры для обновления
включаемых файлов, отдавая предпочтение программным инструменталь-
ным средствам, чтобы оповещать членов группы о том, что две компиляции
не используют одну и ту же версию включаемого файла.

Инкапсуляция
Конструкции with позволяют разработчику программного обеспечения точно определить зависимости между модулями и использовать порожденные пакеты дли разработки модульных структур с иерархической достижимостью.
Java содержит конструкцию инкапсуляции, названную пакетом (package)
но, к сожалению, конструкция эта по духу ближе к пространству имен (names-
pace) в языке C++, чем к пакету Ada! Пакет является совокупностью классоd:
package Airplane_Package; Java
public class Airplane_Data
{
int speed; // Доступно в пакете
private int mach_speed; // Доступно в классе
public void set_speed(int s) {...}; // Глобально доступно
public int get_speed() {...};
}
public class Airplane_Database
{
public void new_airplane(Airplane_Data a, int i)
{
if (a.speed > 1000) // Верно!
a.speed = a.mach_speed; // Ошибка!
}

private Airplane_Data[ ] database = new Airplane_Data[1000];

}

Пакет может быть разделен на несколько файлов, но файл может содержать
классы только из одною пакета.
Спецификаторы public и private аналогичны принятым в языке С++: pub-
lic (общий) означает, что элемент доступен за пределами класса, в то время как
private (приватный) ограничивает достижимость для других членов класса. Ес-
ли никакой спецификатор не задан, то элемент видим внутри пакета. В приме-
ре мы видим, что элемент int speed (скорость) класса Airplane_Data не имеет
никакого спецификатора, поэтому к нему может обратиться оператор внутри
класса Airplane_Database, так как два класса находятся в одном и том же паке-
те. Элемент mach_speed объявлен как private, поэтому он доступен только
внутри класса Airplane_Data, в котором он объявлен.
Точно также классы имеют спецификаторы достижимости. В примере оба
класса объявлены как public, что означает, что другие пакеты могут обращаться к любому (public) элементу этих классов. Если ласс объявлен как private,
он доступен только внутри пакета. Например, мы могли бы объявить privatе
класс Airplane_File, который использовался бы внутри пакета для записи в ба-
зу данных.
Пакеты играют важную роль в развитии программного обеспечения Java,
потому что они позволяют группировать вместе связанные классы при сохра-
нении явного контроля над внешним интерфейсом. Иерархическая библио-
течная структура упрощает построение программных инструментальных
средств.

Сравнение с другими языками
Пакеты Java служат для управления глобальными именами и достижимостью
аналогично конструкции namespace в языке С++. При заданных в нашем
примере объявлениях любая Java-программа может содержать:
Airplane_Package.Airplane_Data a; Java
a.set_speed(100);
потому что имена класса и метода объявлены как public. He изучив полный
исходный текст пакета, нельзя узнать, какие именно классы импортированы.
Есть оператор import, который открывает пространство имен пакета, разре-
шая прямую видимость. Эта конструкция аналогична конструкциям using и
C++ и use в Ada.
Основное различие между Java и Ada состоит в том, что в Ada специфика-
ция пакета и тело пакета разделены. Это не только удобно для сокращения
размера компиляций, но и является существенным фактором в разработке и
поддержке больших программных систем. Спецификация пакета может быть
заморожена, позволяя параллельно разрабатывать тело пакета и вести разра ботку других частей. В Java «интерфейс» пакета является просто совокупно-
стью всех public-объявлений. Разработка больших систем на Java требует, что-
бы программные инструментальные средства извлекали спецификации паке-
та и гарантировали совместимость спецификации и реализации.
Конструкция пакета дает Java одно главное преимущество перед C++.
Пакеты сами используют соглашение об иерархических именах, которое
позволяет компилятору и интерпретатору автоматически размещать клас-
сы. Например, стандартная библиотека содержит функцию, названную
Java.lang.String.toUpperCase. Это интерпретируется точно так же, как опе-
рационная система интерпретирует расширенное имя файла: toUpperCase
является функцией в пакете Java.lang.String. Библиотеки Java могут (но не
обязаны) быть реализованы как иерархические каталоги, где каждая функ-
ция является файлом в каталоге для своего класса. Отметим, что иерархи-
чность имен как бы вне языка; подпакет не имеет никаких особых привиле-
гий при доступе к своему родителю. Здесь мы видим четкое отличие от
пакетов-детей в Ada, которые имеют доступ к private-декларациям своих
родителей при соблюдении правил, которые не позволяют экспортировать
эти декларации.

9.11. ОБЩИЕ ПОЛОЖЕНИЯ ПРИ СОЗДАНИИ И ЗАПУСКЕ ПРОГРАММЫ НА VISUAL C++6 С КЛАССАМИ И ОБЪЕКТАМИ.

9.11.1. Обзор Visual C++.
Язык С++ идеально подходит для Windows-программирования. Он позволяет хранить большую часть программного кода внутри самостоятельных объектов, а это сокращает объем больших программ (изначально С++ был разработан именно для того чтобы облегчить работу с большими программами). Программировать для Windows стало значительно проще, программы на С++ стало легче отлаживать.
Visual C++ использует MFC (Microsoft Foundation Classes), но и значительно облегчает программирование для Windows благодаря наличию многих вспомогательных инструментов, например, редактора меню или специального редактора для графического проектирования диалоговых окон. Visual C++ представляет собой интегрированную среду разработки, в которой можно писать и запускать программы. Кроме того, все файлы, составляющие программу для Windows, в Visual C++ организуются в виде проектов.

9.11.2. Первая программа
Наш первый пример будет чрезвычайно простым: мы просто выведем на экран сообщение: "Welcome to C++", то есть "Добро пожаловать в С++".
Посмотрим как это делается. Запустите Visual C++ ѕ на экране появится окно (программы на Visual C++, которые мы будем писать в этой книге, как правило, будут иметь собственные окна, но только не в этом примере. Здесь мы займемся созданием консольных программ Win32 ѕ для них окно предоставляет Visual C++ (так как сейчас нас интересует только программирование на С++).

9.11.2.1. Рабочие области и проекты Visual C++.
Наша первая программа будет называться first, и мы создадим ее как новый проект Visual C++. Программные задачи в Visual C++ оформляются в виде проектов; обычно для каждой отдельной программы создается свой проект. Проект (project) представляет собой набор файлов, которые совместно используются для создания одной программы.
Кроме того, сами проекты размещаются в рабочих областях (workspaces), причем одна рабочая область может содержать несколько проектов (активный проект задается в Visual C++ командой Project Ю Set Active Project) (все проекты, созданные нами, будут иметь собственные рабочие области).
Создадим и запустим первый проект:
1. Выполните команду File ЮNew в Visual C++; на экране появится окно New.
2. Перейдите на вкладку Project и выберите из списка строку Win32 Console Application.
3. Введите в текстовом поле Project name имя проекта first, а в поле Location укажите каталог для проекта. В наших примерах используется каталог C:\VCPP, поэтому в поле Location следует ввести строку C:\VCPP\FIRST (вводить надо не вручную, а при помощи иерархического списка).
4. Нажмите кнопку ОК в диалоговом окне New. На экране появиться новое диалоговое окно с именем Win32 Application.
5. Нажмите кнопку Finish ѕ Visual C++ создаст новую программу с именем first. В нее входят два важных файла: first.dsw определяет параметры новой рабочей области, а first.dsp ѕ параметры нового проекта.
Итак, мы создали новую рабочую область, а в ней ѕ проект с именем first.

9.11.2.2. Создание файла с исходным текстом:
Для текста программы нам понадобится новый файл first.cpp. Расширение.срр присваивается файлам с текстами программ на С++.
Создадим файл first.cpp и включим его в проект:
1. Снова выполните команду File Ю New, только на этот раз перейдите на вкладку Files.
2. Выберите из списка строку С++ Source File и введите имя файла first.cpp в текстовом поле File name.
3. Проследите, чтобы флажок Add to project был установлен. Нажмите кнопку ОК.
4. Файл first.cpp создается и открывается в среде Visual C++.
Среда Visual C++состоит из трех основных окон: слева расположено окно просмотра с корешками вкладок в нижней части (Class View и File View). Справа от него находится окно редактора, в котором происходит редактирование документов (в настоящий момент в нем открыт пустой файл first.cpp).Внизу расположено окно результатов со вкладками Build, Debug и Find in Files.

9.11..2.3. Добавление кода на С++:
Теперь мы добавим програмный код в файл first.cpp, который в настоящий момент открыт в окне редактирования Visual C++. Чтобы создать свою первую программу на С++, введем следующий текст:
#include <iostream.h>
void main ()
{
cout << "Welcome to C++ \n";
}
Сначала мы включаем (#include) в программу файл iostream.h. Затем мы определяем функцию с именем main (). Эта функция вызывается при запуске программы. Другими словами, когда вы запускается файл (например, first.exe), Windows ищет в нем функцию main () и выполняет содержащийся в нем код; поэтому мы и включили в нее тот код, который необходимо выполнить.
Теперь рассмотрим то, что она делает ѕ а именно отображение строки на экране при помощи средств ввода/вывода языка С++.

9.11.2.4 Потоки С++
Мы записываем данные в поток С++ с именем cout, для чего используется оператор cout << "Welcome to C++ \n";:
#include <iostream.h>
void maid()
{
· cout << "Welcome to C++ \n";
}
Текст "Welcome to C++ \n" отправляется в выходной поток С++ и попадает прямо на экран. Потоки С++ можно рассматривать как каналы для пересылки данных в различные места; поток cout посылает текст на экран.
Символ \n в конце строки представляет собой служебный символ, который переводит курсор на следующую строку после вывода текста. Приведенная выше строка программы выводит сообщение на экране, посылая его в поток cout.

9.11.2.5 Запуск первой программы
Чтобы запустить нашу программу, сначала необходимо ее откомпилировать, то есть преобразовать в выполняемый файл first.exe. Выполните команду Build Ю Build First.exe, и исходный файл first.cpp будет скомпилирован в first.exe.
Во время компиляции в окне результатов Visual C++ (в нижней части окна Developer Studio) отображается следующий текст:
---Configuration: first ѕ Win32 Debug---
Compiling…
First.cpp
Linking…
First.exe ѕ 0 error(s), 0 warning(s)
Теперь запустите программу командой Build Ю Execute first.exe. На экране появится текст сообщения Welcome to C++ и подсказка Press any key to continue, вставленная Visual C++. Если нажать любую клавишу, окно исчезнет с экрана.
Исходный текст программы из файла first.cpp приведен в листинге:
First.cpp
#include <iostream.h>
void main()
{
cout << "Welcome to C++ \n";
}
На примере этой программы мы познакомились с проектами и рабочими областями Visual C++, с компиляцией программ и с редактированием текстов.

9.11.3. Классы и объекты С++.
Объекты и классы ѕ две фундаментальные концепции всех объектно-ориентированных языков (типа С++).

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

9.11.3.2. Класс
Класс для объекта тоже самое, что форма для печенья; другими словами класс можно рассматривать как шаблон для изготовления объектов. В программировании подобная связь существует между типом данных (например, целочисленными) и переменной. Например, в следующем примере создается целая переменная с именем the_data:
Int the_data;
Именно так создаются целочисленные переменные в С++. Здесь Int- тип переменной, а the_data- имя самой переменной. Аналогичная связь существует между классом и объектом. Например, если заранее подготовить класс screenclass, можно создать объект этого класса с именем screen:
Screenclass screen;
Важно помнить о том, что все рабочие данные хранятся в объекте. Класс не содержит никаких данных; он лишь описывает общую структуру и поведение объекта.
Подведем итог: класс представляет собой программную конструкцию для объединения (или инкапсуляции) функций и данных. Объект можно рассматривать как переменную, тип которой совпадает с данным классом (в комплект С++ входит целая библиотека заранее написанных классов- MFC).

9.11.4. Программа на С++ с классами и объектами.
В следующем примере мы создадим класс DataClass и объект этого класса DataObject.
Создайте в С++ новый проект с именем classes. Затем включите в него новый файл с именем classes.cpp. После этого можно добавить код; как и раньше, начтем со включения файла iostream.h:
® #include <iostream.h>
После этого объявим новый класс DataClass;
#include <iostream.h>
® class DataClass
®{
®}
Новые классы объявляются с ключевым словом class. Оставшаяся часть объявления класса заключается в фигурные скобки { и }. Для хранения данных используются переменные класса. Например, в класс можно включить переменную типа int (то есть целую) с именем PrivateDataMember:
#include <iostream.h>
class DataClass
{
® private:
· int PrivateDataMember;
.
.
.
};
Новая переменная класса имеет целый тип и, соответственно, может хранить целочисленные значения. Обратите внимания на ключевое слово private- оно означает, что переменная класса является закрытой, и с ней могут работать только объекты нашего класса DataClass. Ключевое слово private называется модификатором доступа.

9.11.4.1. Модификатор доступа
Помимо модификатора доступа private, можно воспользоваться модификатором public- он сообщает о том, что переменная класса является открытой и ею можно без всяких ограничений пользоваться в любом месте программы. Есть еще модификатор protected, который ограничивает доступ к переменной и допускает к ней объекты нашего класса, а также объектов классов производных от него.
Воспользуемся ключевым словом public и объявим переменную с именем PublicDataMember:
#include <iostream.h>
class DataClass
{
private:
int PrivateDataMember;
аpublic:

· int PublicDataMember;
.
.
.
};
Теперь давайте включить в класс DataClass какую-нибудь функцию. Функции, принадлежачие классу, называются методами. В нашем примере будет добавлен метод с именем PublicMethod:
#include <iostream.h>
class DataClass
{
private:
int PrivateDataMember;
public:
int PublicDataMember;
int PublicMethod(void);
а
};
Методы обычно работают с внутренними данными класса, причем подробности этой работы скрываются от внешних частей работы, поэтому большую программу жожно разбить на блоки приемлемого размера.
Данные передаются методам в виде переменных, которые называются параметрами. Это может выглядить, например, так: add (variable1, variable2).
Однако наш метод параметров не получает. На это указывает ключевое слово void: int PublicMethod(void) (вместо этого можно написать int PublicMethod()). Кроме того это объявление сообщает, что метод возвращает значение целого типа: для этого в начале объявления ставится ключевое слово int. Итак, наш метод не получает параметров и возвращает целое значение.
Метод PublicMethod() объявлен. Мы отделим определение метода от определения класса и снабдим определение префиксом DataClass:: (он сообщает к какому классу относится определяемый метод):
#include <iostream.h>
class DataClass
{
private:
int PrivateDataMember;
public:
int PublicDataMember;
int PublicMethod(void);
};
аint DataClass::PublicMethod(void)
а{
а};
Теперь все готово для написания кода метода. Наш метод не получает параметров, но возвращает целое значение. Какое значение он должен возвращать? Поскольку переменная PrivateDataMember недоступна за пределами класса, пусть метод PublicMethod возвращает ее значение, чтобы его можно было узнать в любом месте программы.
ПОДСКАЗКА Обращение к закрытым переменным через методы наподобие PublicMethod() входит в число стандартных приемов программирования; тем самым удается ограничить доступ к закрытым данным класса.
Код метода PublicMethod() будет выглядеть так (поскольку он принадлежит классу DataClass, то может беспрепятственно обращаться к закрытой переменной PrivateDataMember):
#include <iostream.h>
class DataClass
{
private:
int PrivateDataMember;
public:
int PublicDataMember;
int PublicMethod(void);
};
int DataClass::PublicMethod(void)
{
а return PrivateDataMember;
}

Метод PublicMethod() должен возвращать значение переменной класса PrivateDataMember — но какое значение в ней будет храниться? Мы еще не инициализировали эту переменную и не присвоили ей никакого значения, так что возвращаемая Методом PublicMethod() величина не будет иметь никакого смысла. Необходимо позаботиться об инициализации PrivateDataMember.

9.11.4.2. Инициализация данных класса в конструкторе
Довольно часто приходится присваивать начальное значение данным создаваемого объекта; например, в классе DataClass нужно инициализировать переменную PrivateDataMember. Для этой цели можно создать отдельный метод или же воспользоваться конструктором класса.
Конструктором класса называется специальный метод, который выполняется в программе при создании объекта данного класса. Как мы сейчас увидим, в конструкторе удобно инициализировать данные класса. Имя конструктора совпадает с именем класса, и он не возвращает никакого значения. Тем не менее, конструктору можно передать любое количество параметров. В нашем примере конструктор будет получать всего один параметр — значение, которое должно быть присвоено PrivateDataMember при создании объекта.
Объявление конструктора выглядит так:
#include <iostream.h>
class DataClass
{
private:
int PrivateDataMember;
public:
а DataClass(int value);
int PublicDataMember;
int PublicMethod(void);
};
Затем необходимо определить конструктор:
#include <iostream.h>
class DataClass
{
private:
int PrivateDataMember;
public:

DataClass(int Value);
Int PublicDataMember;
int PublicMethod(void);
};

а DataClass::DataClass(int Value)
а {
а }
В нашем примере достаточно сохранить переданную величину в PrivateDataMember:

#include <iostream/h>

class DataClass
{
private:
int PrivateDataMember;
public:
DataGlass(lnt value);
int PublicDataMember;
int PublicMethod(void);
};

DataClass::DataClass(int Value)
{
а PrivateDataMember = Value;
}

Готово. У нас есть класс с открытыми и закрытыми переменными и методом, который можно вызывать в программе. Осталось лишь воспользоваться им, и в этом нам поможет функция main().

9.11.4.3. Использование класса DataClass:
Включите в файл classes.cpp функцию main():
#include <iostream.h>

class DataClass
{
private:
int PrivateDataMeniber;
public:
DataClass(int Value);
int PublicDataMember;
int PublicMethod(void);
};
DataClass::DataClass(int Value)
{
PrivateDataMember=Value;
}
int DataClass::PublicMethod(void)
{
return PrivateDataMember;
}

а void main()

а {
а }

Функция main() содержит код, выполняемый при запуске программы. Мы начнем ее с объявления объекта класса DataClass. Одновременно с этим мы передадим значение конструктору класса (оно будет присвоено переменной PrivateDataMember). Пусть это будет значение 1; тогда объект DataObject, принадлежащий классу DataClass, будет создаваться следующим образом:

void main()
{
а DataClass DataObject(1);
…
}

Теперь у нас есть объект с именем DataObject. Он содержит данные, которые мы в него внесли, а также поддерживает метод PublicMethod().

Чтобы присвоить значение открытой переменной класа, PublicDataMember, можно воспользоваться оператором «точка» (.) языка С++. В следующем фрагменте этой переменной присваивается значение 2:

void main()
{
DataClass DataObject(1);
а DataObject.PublicDataMember = 2;
…
}

Обычно все обращения к членам объекта (переменным и функциям) происходят именно так. Например, мы можем вывести значение переменной PublicDataMember, посылая его в поток cout:

void main()
{
DataClass DataObject(1);
DataObject.PublicDataMember = 2;
а cout << "DataObject.PublicDataMember ="
<< DataObject.PublicDataMember << "\n";
…
}

Но как получить значение, присвоенное PrivateDataMember? Поскольку код в функции main() не принадлежит объекту DataObject, из него нельзя напрямую обратиться к закрытой переменой этого объекта. Чтобы добраться до нее надо вызвать метод PublicMethod() и вывести полученное значение:

void main()
{
DataClass Data0bject(1);
DataObject.PublicDataMember =2;

cout << "DataObject.PublicDataMember = "
<< DataObJect.PublicDataMeraber << "\n";

cout << "DataObject.PrivateDataMember = "
<< DataObject.PublicMethod() << "\n";
Программа работы с классами готова — запустите ее. Нам удалось вывести значения и открытой, и закрытой переменных объекта DataClass. Первое знакомство с классами и объектами C++ состоялось.
Ниже приведен текст программы из файла classes.cpp.
classes.cpp
#include <iostream.h>

class DataClass
{
private:
int PrivatDataMember;
public:
DataClass(int Value);

int PublicDataMember;
int. PublicMethod(void);
};
DataClass::DataGlass(int Value),:
{
PrivateDataMember = Value;
}
int DataClass::PublicMethod(void)
{
PrivateDataMember;
}
int DataClass::PublicMethod(void)
{
return PrivateDataMember;
}
void main()
{
DataClass Data0bject(1);
DataObject.PublicDataMember =2;

cout << "DataObject.PublicDataMember = "

<< DataObJect.PublicDataMeraber << \n";
cout << "DataObject.PrivateDataMember = "
<< DataObject.PublicMethod() << "\n";
}

Наш первый пример был крайне примитивным - он всего лишь показал, как создать класс и объект в программе С++. Он совершенно не раскрывает основной смысл объектов — хранение данных и внутреннюю работу с ними. Сейчас мы рассмотрим более реальный пример, который покажет, как работают объекты и для чего они нужны.

9.11.5. Реальный пример на C++.
Давайте рассмотрим более жизненный пример на C++, который бы продемонстрировал возможности объектов по внутренней обработке данных.
Предполагается, что в новом примере мы будем обрабатывать для двух учебных предметов — истории и английского языка—результаты контрольных работ. Мы создадим объект, сохраняющий все оценки и вычисляющий средний балл по каждому предмету. Новый пример называется school гооm.
Создайте проект schoolroom и добавьте в него новый файл schoolroom.cpp. Мы создадим класс с именем SchoolClass для хранения и обработки оценок:
#include <iostream.h>
а class SchoolClass {
а };
Сведения об оценках будут храниться в области памяти с именем ClassData. Переменная ClassData, которую мы сейчас создадим, представляет собой указатель на начало данных, хранящихся в памяти. Для выделения области памяти необходимого размера нужно знать, сколько студентов участвовало в контрольной (это количество будет передаваться конструктору в качестве параметра).
ПРИМЕЧАНИЕ: Указатель — это переменная, в которой хранился адрес области памяти. В языках С и C++ имя массива представляет собой указатель на начало данных массива в памяти. Чтобы объявить указатель в С и C++, следует снабдить имя переменной префиксом * ("звездочка").
Мы также создадим в области данных целую индексную переменную ClassDataIndex, определяющую наше положение относительно начала массива при добавлении сведений о новом ученике:
#include <iostream.h>

.
class SchoolClass {
а int «ClassData;
а int ClassDataIndex;