Несмотря на все многообразие средств, предоставляемых Си++, совершенно необязательно использовать их все сразу. Первым шагом при переходе от Си к Си++ может стать изменение расширений имен исходных файлов ваших программ. Вместо традиционного расширения C в языке Си++ принято использовать расширение CPP. Теперь ваша программа будет транслироваться, как программа, написанная на языке Си++.
Затем вы можете использовать все новые и новые особенности Си++, постепенно отходя от стандартного Си к Си++. На момент написания книги окончательный стандарт Си++ еще не был разработан. Компиляторы различных фирм, например Microsoft и Borland имеют различия в реализации Си++. Наша книга ориентирована в первую очередь на компиляторы Microsoft Visual C++ версий 1.5, 2.0, 4.0 и 4.1.
Конечно, в одной главе мы не можем рассказать обо всех возможностях языка Си++. Поэтому мы изучим только основные особенности языка Си++. Более подробную информацию вы можете получить из справочников или учебников по языку Си++.
Как вы знаете, операторы << и >> выполняют сдвиг числового значения влево и вправо на опеределенное число бит. В программах, приведенных в нашей книге, эти операторы также используются для ввода информации с клавиатуры и вывода на экран.
Если с левой стороны от оператора << расположен символ cout, то этот оператор осуществляет вывод на экран информации, указанной справа от оператора. Форма, в которой выполняется вывод на экран, зависит от типа выводимого значения. Используя оператор <<, вы можете отображать на экране текстовые строки, а также значения переменных различных типов. В качестве левого параметра оператора << можно использовать не только cout, но также результат работы предыдущего оператора <<. Это позволяет строить цепочки из операторов <<. Чтобы перейти к отображению следующей строки, вы можете передать cout значение \n.
Так, например, следующий фрагмент кода отображает на экране значения переменных iInt, cChar и szString с соответствующими комментариями:
cout << “Значение переменной iInt = ”; cout << iInt; cout << “\n”; cout << “Значение переменной cChar = ” << cChar << “\n”; cout << “Строка szString = ” << szString << “\n”;
Оператор >> и символ inp предназначены для ввода данных. Они позволяют пользователю ввести с клавиатуры значение какой-либо переменной. Ниже мы привели пример, в котором для ввода целочисленного значения используется inp и оператор >>:
int iNum; cout << “Введите целочисленное значение:”; cin >> iNum;
Чтобы воспользоваться возможностями потокового ввода/вывода, необходимо включить в программу файл iostream.h.
Забегая вперед, скажем, что символы inp и outp, которые иногда называют потоками, представляют собой объекты специального класса, предназначенного для ввода и вывода информации. Операторы << и >> переопределены в этом классе и выполняют новые функции. О переопределении операторов вы можете прочитать в разделе “Перегрузка операторов”.
В Си++ существует удобное средство определения констант. Если в Си вы должны были пользоваться директивой препроцессора #define, то теперь введено новое ключевое слово const, позволяющее создавать константы. Преимущество в использовании ключевого слова const перед директивой #define состоит в том, что компилятор проверяет тип этих констант.
Ключевое слово const XE "const" указывают перед объявлением переменной. Такая переменная не может быть модифицирована. Попытки изменить ее вызывают ошибку на этапе компиляции.
В программе, приведенной ниже, объявляются две константы. Одна типа int, другая типа char:
// Включаемый файл для потокового ввода/вывода
#include <stdio.h>
int main(void)
{
// Объявляем две константы
const int max_nuber = 256;
// Выводим текстовую строку на экран
printf("Const Number is %d \n", max_nuber);
return 0;
}
Ключевое слово const можно указывать при объявлении постоянных указателей, которые не могут менять своего значения. Заметим, что объект (переменная), определяемый постоянным указателем, может быть изменен:
int iNumber; int *const ptrNumber = &iNumber;
В языке Си++ вы можете определить ссылку XE "ссылки" на объект - переменную или объект класса. Ссылка содержит адрес объекта, но вы можете использовать ее, как будто она представляет сам объект. Для объявления ссылки используется оператор &.
В следующей программе мы определили переменную iVar типа int и ссылку iReferenceVar на нее. Затем мы отображаем и изменяем значение переменной iVar используя ее имя и ссылку.
// Включаемый файл для потокового ввода/вывода
#include <iostream.h>
void main(void)
{
// Определяем переменную iVar
int iVar = 10;
// Определяем ссылку iReferenceVar на переменную iVar
int& iReferenceVar = iVar;
// Отображаем значение переменной и ссылки
cout << "iVar = " << iVar << "; iReferenceVar = " <<
iReferenceVar << '\n';
// Изменяем значение переменной iVar пользуясь ссылкой
iReferenceVar = 20;
// Отображаем значение переменной и ссылки
cout << "iVar = " << iVar << "; iReferenceVar = " <<
iReferenceVar << '\n';
}
Вы можете использовать ссылки для передачи параметров функциям. При этом фактически вы передаете функции указатель на объект, представленный ссылкой. Внутри функции вы можете работать с ссылкой как с самим объектом, а не как с указателем.
Функция может не только принимать ссылки в качестве своих параметров, она также может возвращать ссылку. Такую функцию можно привести в левой части оператора присваивания.
Стандартная библиотека компиляторов содержит специальные функции управления памятью - malloc, free, а также другие разновидности этих функций. Они позволяют получить для использования блок оперативной памяти, и затем отдать его обратно операционной системе.
В Си++ встроены специальные операторы для управления памятью - оператор new XE "new" и оператор delete XE "delete". Эти операторы очень удобны для динамического создания переменных, массивов и объектов классов, поэтому мы остановимся на них более подробно.
Оператор new создает объект заданного типа. При этом он выделяет память, необходимую для хранения объекта и возвращает указатель, указывающий на него. Если по каким-либо причинам получить память не удается, оператор возвращает нулевое значение. Оператор new позволяет сразу инициализировать созданную переменную. Приведем формат оператора new:
new type-name [initializer]; new (type-name) [initializer];
В качестве аргумента type-name надо указать имя типа создаваемого объекта. Дополнительный аргумент initializer позволяет присвоить созданному объекту начальное значение. Вот простой пример вызова оператора new:
char *litera; int *pi; litera = new char; pi = new int(3,1415);
В этом примере оператор new используется для создания двух объектов - одного типа char, а другого типа int. Указатели на эти объекты записываются в переменные litera и pi. Заметим, что объект типа int сразу инициализируется значением 3,1415.
Чтобы освободить память, полученную оператором new, надо вызвать оператор delete. Вы должны передать оператору delete указатель pointer, ранее полученный оператором new:
delete pointer;
Оператор new позволяет создавать объекты не только простых типов, он может использоваться для динамического создания массивов. Следующий фрагмент кода создает массив из ста элементов типа long. Указатель на первый элемент массива записывается в переменную pData:
long *pData = new long[100];
Чтобы удалить массив, созданный оператором new, надо воспользоваться другой формой вызова оператора delete:
delete [] pointer;
Прямоугольные скобки указывают на то, что надо удалить массив элементов.
В соответствии с правилами языка С различные функции, определенные в программе, должны иметь разные имена. Это не всегда удобно, так как могут быть несколько функций, выполняющих сходные действия, но немного отличающиеся по набору параметров.
Язык С++ позволяет иметь несколько функций с одинаковыми именами, но различным набором параметров. Такие функции называются перегруженными XE "перегруженные функции", так как одно и то же имя используется для обозначения различных функций.
В качестве примера рассмотрим функции Sqware, предназначенные для вычисления площади прямоугольников и квадратов:
int Sqware(int a, int b); int Sqware(int a);
Как видите, эти функции имеют одинаковые имена, но разные параметры. Первая функция, предназначенная для вычисления площади прямоугольника имеет два параметра, задающие длины его сторон. Вторая функция позволяет вычислить площадь квадрата и содержит только один параметр, определяющий длину стороны квадрата. Вот определения этих функций:
int Sqware(int a, int b) {
return (a * b);
}
int Sqware(int a) {
return (a * a);
}
Вы можете вызывать обе функции Sqware из своей программы. Компилятор определит по количеству и типу параметров, какую конкретно функцию надо выполнить:
void main() {
int value;
value = Sqware(10, 20);
print("Площадь прямоугольника равна %d", value);
value = Sqware(10);
print("Площадь квадрата равна %d", value);
}
Еще одна интересная возможность, которая появляется у вас после перехода от Си к Си++, позволяет при определении функций задавать некоторые ее параметры по умолчанию. Вызывая такую функцию, можно не указывать параметры, заданные по умолчанию.
Если большинство вызовов функции выполняется с одинаковыми параметрами, это позволяет сократить текст программы, а главное, уменьшить возможность совершения ошибок во время набора параметров функции.
Параметры по умолчанию можно задать во время объявления функции или во время ее определения. По умолчанию задают только последние параметры функций:
int Summa(int first, int second, int third=0, int fourth=0) {
return(first + second + third + fourth);
}
Функцию Summa можно использовать для сложения четырех, трех или двух чисел. Если складываются два числа, то третий и четвертый параметр можно опустить:
void main() {
int value1 = 10, value2 = 20, value3 = 30, value4 = 40;
int result;
// Вызываем функцию с четырьмя параметрами
result = Summa(value1, value2, value3, value4);
print("Сумма четырех чисел равна %d", result);
// Вызываем функцию с тремя параметрами
result = Summa(value1, value2, value3);
print("Сумма трех чисел равна %d", result);
// Вызываем функцию с двумя параметрами,
// последний параметр задается по умолчанию
result = Summa(value1, value2);
print("Сумма первых двух чисел равна %d", result);
}
В некоторых XE "встраивание" случаях более удобно и эффективно выполнять подстановку тела функции вместо ее вызова. Непосредственная подстановка тела функции позволит сэкономить время процессора на вызове функции. В языке Си этого можно достичь при помощи директивы препроцессора #define. Однако неправильное использование директивы может стать причиной ошибок.
Си++ предусматривает специальный механизм для встраивания функций. Чтобы указать компилятору, что данную функцию необходимо встраивать, перед ее объявлением или определением надо указать ключевое слово inline XE "inline" :
inline unsigned int Invert(unsigned int number) {
return (~number);
}
В программах, написанных на языке С, данные и функции, предназначенные для их обработки определяются отдельно. Такое разделение затрудняет структурированное программирование и создает дополнительные возможности для ошибок, которые трудно обнаружить.
В С++ введено новое понятие - класс. Класс позволяет объединить данные и оперирующие ими функции в одной структуре. Такое объединение обычно называют инкапсуляцией данных и связанных с ними функций. Инкапсуляция позволяет скрыть конкретную реализацию класса, облегчая отладку и модификацию программ.
Объявление класса имеет следующий вид:
class [<tag>]
{
<member-list>
} [<declarators>];
Когда вы определяете класс, то сначала указывается ключевое слово class, а затем в качестве аргумента <tag> имя самого класса. Это имя должно быть уникальным среди имен других классов, определенных в вашей программе.
Затем в фигурных скобках следует список элементов класса <member-list>. В качестве элементов класса могут фигурировать данные (переменные), битовые поля, функции, вложенные классы, а также некоторые другие объекты. Вы можете включить качестве элемента класса указатель на другие объекты этого класса.
Классы образуют собственное пространство имен. Имена элементов одного класса могут совпадать с именами элементов другого класса и даже с именами других переменных и функций определенных в программе.
Функции входящие в класс, называются функциями-элементами, или следуя терминологии объектно-ориентированного подхода, методами. Далее мы будем называть такие функции методами. Внутри класса вы можете свободно обращаться ко всем его элементам функциям и данным, без указания имени класса или имени объекта этого класса.
После закрывающей фигурной скобки в аргументе <declarators> можно объявить один или несколько объектов данного класса. Объекты класса можно объявить и позже, точно так же как объявляются переменные простых типов:
[class] tag declarators;
Ключевое слово class перед именем класса можно опустить.
Для динамического создания и удаления объектов классов можно пользоваться операторами new и delete. Эти операторы позволяют легко строить списки классов, деревья и другие сложные структуры.
Ключевое слово this XE "this" представляет собой указатель на текущий объект класса. Методы класса могут использовать ключевое слово this чтобы получить указатель на объект для которого вызван данный метод. Указатель this представляет собой постоянную величину, вы не можете изменять его значение в своей программе.
Определив класс, вы можете создавать объекты этого класса и манипулировать ими, используя методы. Некоторые данные и методы, объединенные одним классом, можно сделать недоступными вне реализации класса, к другим можно будет обращаться из программы.
Для управления доступом к элементам класса предусмотрены ключевые слова public, private и protect (спецификаторы доступа). Методы и данные, определенные или описанные после ключевого слова public представляют собой интерфейс класса - они доступны для использования вне определения класса. Остальные члены класса относятся к его внутренней реализации и обычно недоступны вне класса. Различия между членами класса, описанными после ключевых слов private и protect сказываются только при наследовании от данного класса новых классов. Процедуру наследования мы рассмотрим позже.
Ключевые слова public XE "public", private XE "private" и protect XE "protect" указываются в определении класса перед элементами класса, доступом к которым они управляют. Ключевые слова, управляющие доступом, могут быть указаны несколько раз в одном классе, порядок их расположения значения не имеет. По умолчанию элементы класса являются private. Рекомендуется всегда явно определять права доступа к членам класса.
Ниже представлено определение класса Sample:
class Sample
{
int iX;
void Load();
public:
void SetStr();
void GetStr();
char sDataText[80];
private:
char sNameText[80];
int iIndex;
public:
void ConvertStr();
int iLevel;
};
В классе описаны элементы данных iX, sDataText, sNameText, iIndex, iLevel и методы Load, SetStr, GetStr, ConvertStr.
Элементы данных и методы SetStr, GetStr, sDataText, ConvertStr, iLevel объявлены public. К ним можно обращаться как из методов класса Sample, так и из программы. Остальные элементы класса объявлены как private. Доступ к ним открыт только для методов самого класса, а также дружественных функций и дружественных методов других классов. Дружественные функции и дружественные классы описаны в следующем разделе.
Если исходный текст метода XE "методы" очень короткий, то такой метод обычно определяется непосредственно внутри класса. Вы можете указать, что вместо вызова необходимо выполнять подстановку его тела. Для этого перед ее объявлением следует указать ключевое слово inline XE "inline". Вот пример определения методов SetWeight и GetWeight непосредственно внутри класса:
class line
{
public:
void SetLength(int newLength) { length = newLength; }
int GetLength() { return length; }
private:
int length;
};
Если исходный код методов не такой короткий, то при определении класса указывается только объявление метода, а его определение размещается отдельно. Встраиваемые методы также можно определить вне класса. Когда вы определяете метод отдельно от класса, то имени метода должно предшествовать имя класса и оператор разрешения области видимости :: XE "оператор \:\:".
class convert
{
public:
void GetString() { scanf(sText,"%s"); }
void ShowString() { puts(sText); }
int ConvertString();
void DummyString();
private:
char sText[80];
};
void convert::ConvertString(void)
{
int i;
for(i = 0; sText[i] != '\0'; i++ ) {
sText[i] = tolower(sText[i]);
}
return i;
}
inline void convert::DummyString(void)
{
int i = 0;
while(sText[i++])
sText[i] = 0;
}
Чтобы вызвать метод, надо сначала указать имя объекта класса, для которого будет вызван метод, а затем через точку имя метода. Вместо имени объекта можно использовать указатель на объект. В этом случае вместо символа точки надо использовать оператор -> XE "оператор ->". Если метод вызывается из другого метода этого же класса, то имя объекта и оператор выбора элемента указывать не надо.
Следующий пример демонстрирует вызов методов класса convert, исходный текст которого приведен выше:
void main()
{
convert ObjectA;
ObjectA.GetString();
ObjectA.ConvertString();
ObjectA.ShowString();
convert *pObjectB = new convert;
pObjectB->GetString();
pObjectB->ConvertString();
pObjectB->ShowString();
}
Методы класса могут быть перегружены. В одном и том же классе можно определить несколько методов с одинаковыми именами, но различным набором параметров.
Обычно при создании объекта класса необходимо провести начальную инициализацию объекта, например выделить участок памяти для размещения каких-либо данных, связанных с этим объектом. После окончания использования объекта выделенную память надо освободить и отдать обратно операционной системе.
Язык С++ предоставляет удобное средство для инициализации и удаления объектов класса. Для этого предусмотрены специальные методы. Они называются конструкторами XE "конструктор" и деструкторами XE "деструктор".
Функция конструктор имеет такое же имя как имя класса и позволяет выполнить инициализацию объекта класса в момент его создания. Конструктор может иметь параметры. Их надо будет указать при определении объекта данного класса. Класс может иметь несколько конструкторов с разными параметрами, то есть конструкторы могут быть перегружены.
Класс BookList, представленный ниже, имеет два конструктора BookList. Первый конструктор не имеет параметров, второй конструктор имеет один параметр типа int:
class BookList
{
// Конструкторы класса
void BookList();
void BookList(int);
// Остальные члены класса
};
// Первый конструктор класса
BookList::BookList(void)
{
}
// Второй конструктор класса
BookList::BookList(int iList)
{
}
Когда вы создаете объекты класса, вы можете указать параметры для конструктора. Ниже создаются два объекта класса BookList - FirstBook и SecondBook:
BookList FirstBook; BookList SecondBook(100);
При создании первого объекта параметры конструктора не указываются, поэтому используется первый конструктор класса. А вот при создании второго объекта мы указали числовой параметр, поэтому в этом случае используется второй конструктор.
Имя деструктора также соответствует имени класса, но перед ним должен стоять символ тильда. Деструктор вызывается автоматически, когда объект уничтожается. Например, если определить объект данного класса внутри блока, то при выходе из блока для объект будет вызвана функция деструктор. Функция деструктор не имеет параметров, поэтому она не может быть перегружена, а значит у данного класса может быть только один деструктор.
Ниже представлен класс Object, для которого определен деструктор ~Object:
class Object
{
void ~Object();
// Остальные члены класса
};
Object::~Object(void)
{
}
Если метод не изменяет объект, для которого он вызывается, такой метод можно объявить с ключевым словом const XE "const". Ключевое слово const указывается после закрывающей скобки списка аргументов метода. Вы должны указать, что метод не изменяет объект и в объявлении и в определении метода.
Методы, объявленные как const XE "методы const", не могут изменять элементы класса или вызывать другие методы, объявленные без ключевого слова const. Нарушение этих правил вызовет ошибку на этапе компиляции приложения.
В библиотеке классов MFC вы встретите много методов, объявленных как const. Их использование повышает надежность приложения, так как компилятор сможет обнаружить ошибки, связанные с непреднамеренным изменением элементов класса.
Ниже мы привели пример класса, для которого метод GetWeight определен как const. Если вы попытаетесь модифицировать элемент данных weight непосредственно из метода GetWeight, компилятор сообщит об ошибке.
#include <iostream.h>
void main(void);
// Класс ClassMen включает элемент данных и два метода для
// обращения к нему
class ClassMen
{
public:
void SetWeight(int newWeight);
int GetWeight() const;
private:
int weight;
};
// Метод GetWeight позволяет определить значение элемента
// weight. Этот метод объявлен как const и не может
// модифицировать объекты класса ClassMen
int ClassMen::GetWeight() const
{
return weight;
}
// Метод SetWeight позволяет изменить значение weight.
// Такой метод нельзя объявлять как const
void ClassMen::SetWeight(int newWeight)
{
weight = newWeight;
}
// Главная функция программы
void main(void)
{
// Создаем объект класса ClassMen
ClassMen alex;
// Устанавливаем значение элемента weight объекта alex
alex.SetWeight(75);
// Отображаем значение элемента weight объекта alex
cout << alex.GetWeight() << "\n";
}
Вы можете объявить некоторые методы класса статическими методами. Для этого вы должны воспользоваться ключевым словом static. Статические методы не принимают параметр this XE "this". На использование статических методов накладывается ряд ограничений.
Статические методы имеют одну интересную особенность - вы можете вызывать их даже без создания объектов класса. Чтобы вызвать из программы статический метод, вы должны указать его полное имя, включая имя класса.
Ниже представлен класс Circle, в котором определена статический метод GetPi. Он используется для получения значения статического элемента класса fPi.
class Circle
{
public:
static void GetPi()
{ return fPi; }
private:
static float fPi;
};
float Circle::fPi = 3.1415;
Вы можете вызвать метод GetPi следующим образом:
class Circle
{
public:
static void GetPi()
{ return fPi; }
private:
static float fPi;
};
float Circle::fPi = 3.1415;
Обратите внимание, что объект класса Circle не создается.
Иногда удобно, чтобы все объекты данного класса имели общие элементы данных, которые используются совместно. За счет этого можно существенно сократить количество глобальных переменных, улучшая структуру программы.
Общие элементы данных класса следует объявить с ключевым словом static. Все общие элементы класса надо определить в тексте программы, зарезервировав за ними место в оперативной памяти:
class CWindow
{
public:
int xLeftTop, xRightBottom;
int yLeftTop, yRightBottom;
static char title[80];
void SetTitle(char*);
};
char Cwindow::title[80] = "заголовок окна";
Каждый объект класса Cwindow будет иметь уникальные координаты, определяемые элементами данных xLeftTop, xRightBottom, yLeftTop, yRightBottom и одинаковый заголовок, хранимый элементом данных title.
Общие элементы данных находятся в области действия своего класса. Методы класса могут обращаться к общим элементам точно так же, как к остальным данным из класса:
void SetTitle(char* sSource)
{
strcpy(title, sSource);
}
Чтобы получить доступ к общим элементам из программы, надо объявить их как public XE "public". Для обращения к такой переменной перед ее именем надо указать имя класса и оператор :: XE "оператор \:\:".
printf(Cwindow::title);
Доступ к элементам класса из программы и других классов ограничен. Вы можете непосредственно обращаться только к элементам класса, определенным или описанным после ключевого слова public. Однако, в некоторых случаях, требуется определить функцию вне класса или другой класс, методы которого могут обращаться непосредственно ко всем элементам класса, включая элементы объявленные как private и protect.
В Си++ вы можете определить для класса так называемую дружественную функцию, воспользовавшись ключевым словом friend. В классе содержится только объявление дружественной функции. Ее определение расположено вне класса. Вы можете объявить дружественную функцию в любой секции класса - public, private или protect.
Дружественная функция не является элементом класса, но может обращаться ко всем его элементам, включая private и protect. Одна и та же функция может быть дружественной для двух или более классов.
В следующем примере определена функция Clear, дружественная для класса point. Дружественная функция Clear используется для изменения значения элементов данных m_x и m_y, объявленных как private:
//==========================================================
// Класс point
class point
{
public:
// Функция Clear объявляется дружественной классу point
friend void point::Clear(point*);
// Интерфейс класса...
private:
int m_x;
int m_y;
};
//==========================================================
// Функция Clear
void Clear(point* ptrPoint)
{
// Обращаемся к элементам класса, объявленным как private
ptrPoint->m_x = 0;
ptrPoint->m_y = 0;
return;
}
//==========================================================
// Главная функция
void main()
{
point pointTestPoint;
// Вызываем дружественную функцию
Clear(&pointTestPoint);
}
С помощью ключевого слова friend вы можете объявить некоторые методы одного класса дружественными для другого класса. Такие методы могут обращаться ко всем элементам класса, даже объявленным как private и protect, несмотря на то, что сами они входят в другой класс.
В следующем примере мы определяем два класса - line и point. В классе point определяем метод Set и объявляем его в классе line как дружественный. Дружественный метод Set может обращаться ко всем элементам класса line:
// Предварительное объявление класса line
class line;
//==========================================================
// Класс point
class point
{
public:
// Метод Set класса point
void Set(line*);
//...
};
//==========================================================
// Класс line
class line
{
public:
// Метод Set класса point объявляется дружественной
// классу point
friend void point::Set(line*);
private:
int begin_x, begin_y;
int end_x, end_y;
};
//==========================================================
// Функция Clear
void point::Set(line* ptrLine)
{
// Обращаемся к элементам класса line, объявленным как
// private
ptrLine->begin_x = 0;
ptrLine->begin_y = 0;
//...
return;
}
//==========================================================
// Главная функция
void main()
{
point pointTestPoint;
line lineTestPoint;
// Вызываем дружественный метод
pointTestPoint.Set(&lineTestPoint);
}
По аналогии с дружественными функциями и методами, можно объявить дружественный класс. Все методы дружественного класса, могут обращаться ко всем элементам класса, включая элементы, объявленные как private и protect.
Так, например, в предыдущем примере вы могли бы определить, что класс point является дружественным классу line. Все методы класса point могут обращаться к любым элемента класса line.
//==========================================================
// Класс point
class point
{
//...
};
//==========================================================
// Класс line
class line
{
public:
// Класс point объявляется дружественным классу line
friend class point;
};
Пожалуй, самая важная возможность, предоставляемая программисту средствами языка Си++, заключается в механизме наследования XE "наследование". Вы можете наследовать от определенных ранее классов новые производные классы. Класс, от которого происходит наследование, называется базовым. Новый класс называется производным.
Производный класс включает в себя элементы базового класса и может дополнять их собственными элементами данных и методами. За счет наследования появляется возможность повторного использования кода программы.
Производный класс сам может служить базовым классом XE "базовый класс". Вы можете наследовать от него другие классы. Полученный в результате такого наследования класс будет включать в себя элементы всех его базовых классов.
От одного общего базового класса можно наследовать несколько новых производных классов. Производный класс сам может служить базовым классом для новых классов. Таким образом возможна древовидная структура наследования классов.
На рисунке 1.1 мы привели пример структуры наследования классов. От единственного базового класса BaseClass наследуются три класса DerivedClassOne, DerivedClassSecond и DerivedClassThird. Первые два из них сами выступают в качестве базовых классов.
Рис. 1.1. Наследование
Практически вся структура библиотеки классов MFC основывается на механизме наследования. Так, например, большинство классов MFC имеет базовый класс CObject, который обеспечивает наиболее общие свойства унаследованных от него классов.
Можно выделить две основных формы наследования. Когда производный класс наследуется от единственного базового класса - единичное наследование. Наследование, при котором производный класс наследуется сразу от нескольких базовых классов - это множественное наследование.
В случае единичного наследования XE "наследование:единичное" порожденный класс наследуется только от одного базового класса. Рисунок 1.1 отражает единичное наследование классов. Единичное наследование является наиболее распространенным методом наследования. Библиотека классов MFC использует только единичное наследование.
Чтобы указать, что класс наследуется от другого базового класса, имя базового класса <base> необходимо указать после имени класса перед открывающей фигурной скобкой определения класса. Непосредственно перед именем базового класса необходимо поставить знак двоеточия:
class [<tag>[:<base>]]
{
<member-list>
} [<declarators>];
Перед названием базового класса может быть указан спецификатор доступа public, private или protect. Назначение этих спецификаторов мы рассмотрим в разделе “Разграничение доступа к элементам базового класса”. Сейчас же мы скажем только, что если вы не укажите спецификатор доступа, то по умолчанию будет подразумеваться спецификатор private.
Ниже мы определили базовый класс Base, содержащий несколько элементов, а затем наследовали от него два новых класса DerivedFirst и DerivedSecond. В каждом из порожденных классов мы определили различные дополнительные методы и элементы данных.
// Класс Base
class Base
{
// Элементы класса Base
};
// Класс DerivedFirst, наследованный от базового класса Base
class DerivedFirst : Base
{
// Элементы класса DerivedFirst
};
// Класс DerivedSecond, наследованный от базового класса Base
class DerivedSecond : Base
{
// Элементы класса DerivedSecond
};
Классы DerivedFirst и DerivedSecond сами могут выступать в качестве базовых классов.
Вы можете определять в пороженном классе элементы, имена которых совпадают с именами элементов базовых классов. Если вы выполнили такое переопределение, вы можете обратиться к элементу базового класса, если укажете его полное имя. Полное имя должно состоять из имени класса, к которому относится элемент, оператора :: и имени самого элемента.
В качестве примера приведем базовый класс Base и производный от него класс Derived. В обоих классах определен элемент данных iNumber. Чтобы получить доступ из порожденного класса к элементу iNumber базового класса указывается его полное имя Base::iNumber.
// Класс Base
class Base
{
public:
int iNumber;
// Другие элементы класса
};
// Класс Derived, наследованный от базового класса Base
class Derived : Base
{
public:
// Это объявление скрывает элемент iNumber базового класса
int iNumber;
int GetNumber(void) {return iNumber + Base::iNumber; }
};
Указатель на объект базового класса можно присвоить указатель на объект класса порожденного от него. Эта возможность будет широко использоваться в библиотеке классов MFC.
Множественное наследование XE "наследование:множественное" выполняется подобно единичному наследованию. В отличие от единичного наследования у порожденного класса может быть несколько базовых классов. На рисунке 1.2 представлен пример множественного наследования классов. Класс DerivedClaass имеет два базовых класса BaseClassOne и BaseClassSecond. Класс DerivedClaass и еще один класс BaseClass используются при множественном наследовании класса DerivedClaassSecond.
Рис. 1.2. Множественное наследование
Вместо имени единственного базового класса указывается список <base-list> имен базовых классов, разделенный запятыми. Непосредственно перед названиями базовых классов могут быть указаны спецификаторы доступа public, private и protect. Их назначение мы рассмотрим в разделе “Разграничение доступа к элементам базового класса”.
class [<tag>[:[<base-list>]]
{
<member-list>
} [<declarators>];
Порядок, в котором вы перечислите базовые классы влияет только на последовательность в которой вызываются конструкторы и деструкторы базовых классов. Конструкторы базовых классов вызываются в том порядке, в котором они перечислены (слева на право). Деструкторы базовых классов вызываются в обратном порядке.
Один и тот же класс нельзя указывать два или более раза в качестве базового класса (за исключением тех случаев, когда он является непрямым базовым классом).
В следующем примере определены два базовых класса BaseFirst и BaseSecond. От них наследован один новый класс Derived. Результирующий класс Derived объединяет элементы обоих базовых классов и добавляет к ним собственные элементы.
// Класс BaseFirst
class BaseFirst
{
// Элементы класса BaseFirst
};
// Класс BaseSecond
class BaseSecond
{
// Элементы класса BaseSecond
};
// Класс Derived, наследованный от базового класса Base
class Derived : BaseFirst, BaseSecond
{
// Элементы класса Derived
};
Так как библиотека классов MFC XE "библиотека MFC" не использует множественное наследование, мы не станем останавливаться на нем более подробно. При необходимости вы можете получить дополнительную информацию из справочников или учебников по языку Си++ (см. список литературы).
Мы уже рассказывали, что можно управлять доступом к элементам класса, указывая спецификаторы доступа для элементов класса. Элементы класса, объявленные с спецификаторами protected XE "protected" и private XE "private" доступны только из методов самого класса. Элементы с спецификаторами public XE "public" доступны не только из методов класса, но и извне.
При создании порожденного класса встает вопрос о доступе к элементам базового класса. Оказывается, когда вы наследуете класс из базового класса, вы можете управлять разграничением доступа к элементам базового класса. При этом имеет значение то, как объявлены элементы базового класса и какой спецификатор доступа указан для базового класса.
По следующей таблице вы можете определить как будут доступны элементы базового класса в зависимости от спецификатора доступа базового класса и спецификаторов доступа элементов базового класса.
Спецификатор доступа базового класса |
|||
Спецификатор доступа элемента базового класса |
public |
protected |
private |
public |
Доступны как public |
Доступны как protected |
Доступны как private |
protected |
Доступны как protected |
Доступны как protected |
Доступны как private |
private |
Недоступны |
Недоступны |
Недоступны |
В порожденном классе можно определить методы и элементы данных с именами, которые уже используются в базовом классе. Соответствующие методы и элементы данных базового класса оказываются скрыты. Чтобы обратиться к ним, необходимо указывать полное имя, включающее имя базового класса, оператор :: и имя элемента класса.
Методы базового класса могут быть переопределены в порожденных классах. Если вы создадите объект порожденного класса и вызовете для него переопределенный метод, то будет вызван именно метод порожденного класса, а не соответствующий метод базового класса. Однако, если вы вызовете переопределенный метод для объекта порожденного класса, используя указатель или ссылку на объект базового класса, будет вызван именно метод базового класса. Иными словами метод вызывается в соответствии с классом указателя на объект, а не с классом самого объекта.
В Си++ вы можете указать, что некоторые методы базового класса, которые будут переопределены в порожденных классах, являются виртуальными. Для этого достаточно указать перед описанием метода ключевое слово virtual. Статический метод не может быть виртуальным. Методы, объявленные в базовом классе виртуальными считаются виртуальными и в порожденных классах.
Если вы переопределите в порожденном классе виртуальный метод, и создадите объект этого класса, то переопределенный метод будет использоваться вне зависимости от того, как он был вызван. При вызове переопределенного метода играет роль только класс объекта для которого вызывается метод.
Все сказанное нами не означает, что никак нельзя вызвать виртуальный метод базового класса, если он был переопределен. Виртуальный метод базового класса можно вызвать, если указать его полное имя, включая имя базового класса.
Виртуальный метод XE "виртуальные методы" базового класса можно оставить без изменения и не переопределять в порожденном классе. В этом случае, он будет работать как обычный не виртуальный метод.
Следующая программа демонстрирует разницу между виртуальными и невиртуальными методами класса. В базовом классе Figure определены два метода PrintName и PrintDimention, причем метод PrintName определен как виртуальный. От класса Figure наследуется класс Rectangle, в котором методы PrintName и PrintDimention переопределяются.
В программе создается объект класса Rectangle, а затем несколько раз вызываются методы PrintName и PrintDimention. В зависимости от того, как вызывается метод, будет работать метод, определенный в классе Figure или Rectangle.
#include <iostream.h>
// Базовый класс Figure
class Figure
{
public:
// Виртуальный метод
virtual void PrintName(void)
{cout << Figure PrintName << '\n'};
// Невиртуальный метод
void PrintDimention(void)
{cout << Figure PrintDimention << '\n'};
};
// Порожденный класс Rectangle
class Rectangle : public Figure
{
// Переопределяем виртуальный метод базового класса
virtual void PrintName(void)
{cout << Rectangle PrintName << '\n'};
// Переопределяем невиртуальный метод базового класса
void PrintDimention(void);
{cout << Rectangle PrintDimention << '\n'};
};
// Главная функция
void main(void)
{
// Определяем объект порожденного класса
Rectangle rectObject;
// Определяем указатель на объект порожденного класса
// и инициализируем его
*Rectangle ptrRectObject = &rectObject;
// Определяем указатель на объект базового класса Figure
// и записываем в него адрес объекта порожденного класса.
*Figure ptrFigObject = &rectObject;
// Вызываем методы класса Rectangle, используя имя объекта
rectObject.PrintName;
rectObject.PrintDimention;
cout << '\n';
// Вызываем методы класса базового класса Figure
rectObject.Figure::PrintName;
rectObject.Figure::PrintDimention;
cout << '\n';
// Вызываем методы класса Rectangle, используя указатель на
// объекты класса Rectangle
ptrRectObject->PrintName;
ptrRectObject->PrintDimention;
cout << '\n';
// Вызываем методы класса Rectangle, используя указатель на
// объекты класса Figure
ptrFigObject->PrintName;
ptrFigObject->PrintDimention;
}
Если вы запустите приведенную выше программу, она выведет на экран следующую информацию:
Rectangle PrintName Rectangle PrintDimention Figure PrintName Figure PrintDimention Rectangle PrintName Rectangle PrintDimention Figure PrintName Figure PrintDimention
Виртуальные методы могут быть объявлены как чисто виртуальные. Для этого после описания метода указывается специальный спецификатор (= 0). Он означает, что описанные методы не определены.
Класс в котором определен хотя бы один чисто виртуальный метод называется абстрактным XE "абстрактные классы". Нельзя создавать объекты абстрактного класса. Абстрактный класс может использоваться только в качестве базового класса для построения других классов.
Класс, порожденный от абстрактного класса, должен переопределять описанные в нем чисто виртуальные методы. В противном случае этот класс также будет абстрактным.
В качестве примера абстрактного класса мы приведем класс Abstract, в котором описан чисто виртуальный метод PureFunc. Обратите внимание, что этот метод не определен в классе Abstract. Определение метода содержится только в порожденном классе Fact.
// Абстрактный класс Abstract
class Abstract
{
public:
// Чисто виртуальный метод, не имеет определения
virtual int PureFunc(void) = 0;
void SetValue(int i) {iValue = i;}
int iValue;
};
// Класс Fact
class Fact : public Abstract
{
int PureFunc(void) {return iValue * iValue;}
};
Понятие структуры XE "структуры" в языке Си++ значительно расширено. Структура в Си++ обладает всеми возможностями классов. В структуры Си++ можно включать не только элементы данных, но и методы. Вы можете наследовать от структур новые структуры, точно также как вы наследуете новые классы XE "классы" от базовых классов.
Различие между структурами и обычными классами заключается только в управлении доступом к их элементам. Так, если элементы класса по умолчанию объявлены как private XE "private", то все элементы структуры по умолчанию объявлены как public XE "public".
Ниже мы привели пример объявления структуры StructData и класса ClassData, которые содержат одинаковые элементы с одинаковыми правами доступа к ним. Фактически, структура StructData и класс ClassData совершенно равнозначны.
//====================================================
// Класс ClassData
class ClassData
{
int iPrivateValue;
public:
int iPublicValue;
};
//====================================================
// Структура StructData
struct StructData
{
int iPublicValue;
private:
int iPrivateValue;
};
Еще одно различие между структурами и классами проявляется в разграничении доступа к элементам базового класса (см. раздел “Разграничение доступа к элементам базового класса”). Если вы наследуете новый класс от базового класса и не указываете спецификатор доступа, по умолчанию используется спецификатор private. Когда же вы наследуете от базового класса структуру, по умолчанию используется спецификатор public.
Языки программирования С и Си++ обеспечивают строгую проверку типов данных. Некоторые языки не обеспечивают такой проверки и она полностью ложится на плечи программиста. Например в языке PL1 вы можете сравнивать значение строковой и числовой переменных. Это не будет ошибкой с точки зрения компилятора. Если вы случайно допустите ошибку, то обнаружить ее будет достаточно сложно.
Однако строгая типизация, присущая некоторым языкам, не всегда удобна. Если вам надо выполнять одинаковые вычисления над переменными различных типов, придется создавать две фактически одинаковые функции, которые оперируют с различными типами данных.
Аналогичная ситуация возникает, если вам надо создать класс, для работы с различными типами данных. Допустим вам надо создать список из элементов. Удобнее всего это сделать при помощи классов. Но если вам надо, чтобы в качестве элементов списка фигурировали различные типы данных, то вам наверняка придется написать несколько одинаковых классов, различающихся только типом элементов.
Естественно такая ситуация усложняет работу программиста, увеличивают объем исходных текстов программы, и наконец просто может стать причиной ошибок и несоответствий. Так, если в вашей программе содержится несколько функций или классов, отличающихся только типом данных, которыми они оперируют, то когда вы вносите исправления в одну функцию, надо будет точно также исправлять и все остальные.
Чтобы облегчить программисту работу, в стандарт языка Си++ было включено понятие шаблона. В Visual C++ шаблоны реализованы начиная с версии 2.0. Ранние версии Visual C++ с ними работать не могли.
Шаблоны XE "шаблоны" предназначены для создания ряда классов и функций, отличающихся только типом обрабатываемых ими данных. Для определения шаблона предназначено ключевое слово template XE "template" (шаблон). Общий синтаксис определения шаблона имеет следующий вид:
template <template-argument-list> declaration;
Аргумент template XE "template" -argument-list представляет собой список условных имен для определения типов, по которым будут различаться различные реализации классов или функций данного шаблона.
В библиотеке классов MFC определен ряд шаблонов для создания таких структур хранения информации как массив, список, словарь. Более подробно об этих шаблонах вы можете прочитать в разделе “Коллекции” главы “Некоторые классы MFC”.
Си++ позволяет вам легко вводить новые типы данных. Так, например, вы можете определить класс для работы с комплексными числами или числами в полярной системе координат. Естественно, что удобнее всего проводить вычисления с объектами таких классов при помощи операторов, а не специальных методов или функций.
В Си++ вы можете переопределить большинство операторов языка для работы с вашими типами данных. Вот список операторов, которые вы можете переопределить:
! |
= |
< |
> |
+= |
–= |
!= |
, |
–> |
–>* |
& |
| |
( ) |
[ ] |
new |
delete |
>> |
<<= |
^= |
&= |
|= |
<< |
>>= |
== |
~ |
*= |
/= |
%= |
% |
^ |
+ |
- |
* |
/ |
++ |
–– |
<= |
>= |
&& |
|| |
Переопределение операторов вызывает перегрузку операторов. Как в случае перегруженных функций и методов, перегруженные операторы вызываются в зависимости от количества и типа их параметров. О перегруженных функциях вы можете прочитать в разделе “Перегрузка имен функций”.
Для переопределения операторов предназначено ключевое слово operator. Вы должны определить функцию или метод, имя которого состоит из ключевого слова operator и самого оператора. Параметры этой функции должны соответствовать параметрам переопределяемого оператора.
Вы можете переопределить оператор для объектов класса, используя соответствующий метод класса или дружественную функцию класса. Когда вы переопределяете оператор с помощью метода класса, то в качестве неявного параметра метод принимает ключевое слово this XE "this", являющееся указателем на данный объект класса. Поэтому если переопределяется бинарный оператор, то переопределяющий его метод класса должен принимать только один параметр, а если переопределяется унарный оператор - метод класса вообще не должен иметь параметров.
Если оператор переопределяется при помощи дружественной функции, то он должен принимать два параметра для бинарных операторов и один параметр для унарных операторов.
Существует ряд ограничений, которые вы должны учитывать при переопределении операторов:
В нашей первой книге, посвященной языку программирования Си++ и библиотеке классов MFC, мы не будем переопределять операторы. Однако мы будем вызывать операторы, уже переопределенные в классах MFC. Если вы желаете получить больше информации о методике переопределения операторов, обращайтесь к литературе, посвященной языку Си++.
При написании настоящих приложений большую роль играет обработка всевозможных ошибочных ситуаций, возникающих во время работы приложения. В качестве примера таких ошибочных ситуаций может служить неудачная попытка получить блок оперативной памяти, попытка открыть несуществующий файл и т. д.
От того насколько внимательно ваше приложение обрабатывает все ошибочные ситуации, зависит насколько надежно и устойчиво оно будет работать. Например, если приложение по мере своей работы должно получать у операционной системы большие блоки памяти и вы не учтете возможности, что оперативной памяти окажется недостаточно, приложение может вызвать срабатывание защиты памяти.
В языке Си++ реализованы специальные операторы try XE "try", throw XE "throw" и catch XE "catch", предназначенные для обработки ошибочных ситуаций, которые называются исключениями.
Оператор try открывает блок кода, в котором может произойти ошибка. Если ошибка произошла, то оператор throw вызывает исключение. Исключение обрабатывается специальным обработчиком исключений. Обработчик исключения представляет собой блок кода, который начинается оператором catch.
Допустим ваше приложение должно вычислять значение выражения res = 100 / (num * (num - 7)). Если вы зададите значение переменной num, равное 0 или 7, то произойдет ошибка деления на нуль. Участок программы, в котором может случиться ошибка, объединим в блок оператора try. Вставим перед вычислением выражения проверку переменной nem на равенство нулю и семи. Если переменная num примет запрещенные значения, вызовем исключение, воспользовавшись оператором throw.
Сразу после блока try поместите обработчик исключения catch. Он будет вызываться в случае ошибки.
Пример такой программы, получившей название Exception, мы привели в листинге 1.1. Программа Exception принимает от пользователя значение переменной num, а затем вычисляет выражение res = 100 / (num * (num - 7)) и отображает полученный результат на экране.
В случае, если пользователь введет число 0 или 7, тогда вызывается исключение throw. В качестве параметра оператору throw указывается переменная num. Заметим, что так как переменная num имеет тип long, считается что данное исключение также будет иметь тип long.
После вызова оператора throw управление сразу передается обработчику исключения соответствующего типа. Определенный нами обработчик отображает на экране строку "Exception, num = ", а затем выводит значение переменной num.
После обработки исключения, управление не возвращается в блок try, а передается оператору, следующему после блока catch данного обработчика исключения. Программа выведет на экран строку “Stop program” и завершит свою работу.
Если пользователь введет разрешенные значения для переменной num, тогда исключение не вызывается. Программа вычислит значение res и отобразит его на экране. В этом случае обработчик исключения не выполнится и управление перейдет на оператор, следующий за блоком обработки исключения. Программа выведет на экран строку “Stop program” и завершит работу.
Листинг 1.1. Файл Exception.cpp
#include <iostream.h>
int main()
{
long num = 7;
long res = 0;
// Введите число num
cout << "Input number: ";
cin >> num;
// Блок try, из которого можно вызвать исключение
try {
if((num == 7) || (num == 0))
// Если переменная num содержит значение 0 или 7,
// тогда вызываем исключение типа float
throw num;
// Значения num равные 0 или 7 вызовут ошибку
// деления на нуль в следующем выражении
res = 100 / (num * (num - 7));
// Отображаем на экране результат вычисления
cout << "Result = " << res << endl;
}
// Обработчик исключения типа float
catch(long num)
{
// Отображаем на экране значение переменной num
cout << "Exception, num = " << num << endl;
}
cout << "Stop program" << endl;
return 0;
}
В определении обработчика сообщения можно не указывать имя переменной и ограничиться только названием типа. Так, обработчик в предыдущем примере может выглядеть следующим образом:
catch(long)
{
// Отображаем на экране значение переменной num
cout << "Exception, num = " << num << endl;
}
В одном блоке try можно вызывать исключения разных типов. В этом случае после блока try должны следовать обработчики для исключений каждого типа. Вы можете определить обработчик, обслуживающий исключения всех типов. Для этого вместо типа в операторе catch надо указать три точки:
catch(...)
{
...
}
Исключения в языке Си++ могут быть различного типа, в том числе они могут быть объектами классов. Вы можете определить несколько обработчиков исключений различного типа. В этом случае исключение будет обрабатывать обработчик соответствующего типа.
Если вызывается исключение, для которого отсутствует обработчик и не определен универсальный обработчик исключений всех типов, тогда вызывается функция terminate из стандартной библиотеки. Она вызывает функцию abort, завершающую работу программы.
Вы можете определить собственную функцию, которая будет вызываться перед аварийным завершением программы. Для этого вы должны вызвать функцию set_terminate, указав ей в качестве параметра имя вашей функции. Если вы воспользуетесь функцией set_terminate несколько раз, то будет вызываться только функция, указанная в последнем вызове set_terminate.
#include <eh.h>
#include <iostream.h>
#include <process.h>
void FastExit(void);
int main()
{
// Устанавливаем функцию term_func
set_terminate(FastExit);
try
{
//...
// Вызываем исключение типа int
throw (int) 323;
//...
}
// Определяем обработчик типа char. Обработчик исключений
// типа int и универсальный обработчик не определены
catch(char)
{
cout << "Exception " << endl;
}
return 0;
}
// Определение функции FastExit
void FastExit()
{
cout << "Exception handler not found" << endl;
exit(-1);
}
Среда Visual C++ версии 4.0 позволяет запретить или разрешить обработку исключений языка Си++. Для управления исключениями выберите из меню Build строку Settings. На экране появится диалоговая панель Project Settings, в которой определяются все режимы работы. Выберите страницу C/C++. Затем из списка Category выберите строку C++ Language. Чтобы включить обработку исключительных ситуаций установите переключатель Enable exception handling.