Реклама
Основным способом организации информации в Си++ являются классы. В отличие от типа структура (struct) языка Си, которая может состоять только из полей и вложенных типов, класс (class) Си++ может состоять из полей, вложенных типов и функций-членов (member functions). Члены класса бывают публичными (открытыми, public), защищёнными (protected) и собственными (закрытыми, приватными, private). В Си++ тип структура аналогичен типу класс, отличие в том, что по умолчанию члены и базовые классы у структуры публичные, а у класса — собственные.
С открытыми (публичными) членами класса можно делать снаружи класса всё, что угодно. К закрытым (приватным) членам нельзя обращаться извне класса, чтобы не нарушить целостность данных класса. Попытка такого обращения вызовет ошибку компиляции. К таким членам могут обращаться только функции-члены класса (а также так называемые функции-друзья и функции-члены классов-друзей; о понятии друзей в C++ см. ниже). Помимо открытых и закрытых членов класса, могут быть ещё и защищённые — это члены, доступные содержащему их классу, его друзьям, а также производным от него классам. Такая защита членов называется инкапсуляцией.
Используя инкапсуляцию, автор класса может защитить свои данные от некорректного использования. Кроме того, она задумывалась для облегчения совместной разработки классов. Имелось в виду, что при изменении способа хранения данных, если они объявлены как защищённые или собственные, не требуется соответствующих изменений в классах, которые используют изменённый класс. Например, если в старой версии класса данные хранились в виде линейного списка, а в новой версии — в виде дерева, те классы, которые были написаны до изменения формата хранения данных, переписывать не потребуется, если данные были приватными или защищёнными (в последнем случае — если использующие классы не были классами-наследниками), так как ни один из них этих классов не мог бы напрямую обращаться к данным, а только через стандартные функции, которые в новой версии должны уже корректно работать с новым форматом данных. Даже оператор доступа operator [] может быть определён как такая стандартная функция.
Используя инкапсуляцию, структуру Array из предыдущего раздела можно переписать следующим образом:
class Array {
public:
void Alloc(int new_len);
void Free();
inline double Elem(int i);
inline void ChangeElem(int i, double x);
protected:
int len;
double* val;
};
void Array::Alloc(int new_len)
{if (len>0) Free(); len=new_len; val=new double[new_len];}
void Array::Free() {delete [] val; len=0;}
inline double Array::Elem(int i)
{assert(i>=0 && i<len ); return val[i];}
inline void Array::ChangeElem(int i, double x)
{assert(i>=0 && i<len); val[i]=x;}
И далееArray a;
a.Alloc(10);
a.ChangeElem(3, 2.78);
double b = a.Elem(3);
a.Free();
Здесь массив a имеет 4 публичных функции-члена и 2 защищённых поля. Описатель inline означает подсказку компилятору, что вместо вызова функции её код следует подставить в точку вызова, чем иногда можно достичь большей эффективности.
Описание функций в теле класса
В теле класса можно указать только заголовок функции, а можно описать всю функцию. Во втором случае она считается встраиваемой
(inline)
,
например:class Array {
public:
void Alloc(int _len)
{if (len==0) Free(); len=_len; val=new double[len];}
и так далее.
Конструкторы и деструкторы
Однако в приведённом примере не решена важная проблема: функции Alloc и Free по-прежнему надо вызывать вручную. Другая проблема данного примера — опасность оператора присваивания.
Для решения этих проблем в язык были введены конструкторы и деструкторы. Конструктор вызывается каждый раз, когда создаётся объект данного типа; деструктор — при уничтожении. При преобразованиях типов с участием экземпляров классов тоже вызываются конструкторы и деструкторы.
С конструкторами и деструктором класс выглядит так:class Array {
public:
Array() : len(0), val(NULL) {}
Array(int _len) : len(_len) {val = new double[_len];}
Array(const Array& a);
~Array() { Free(); }
inline double Elem(int i);
inline void ChangeElem(int i, double x);
protected:
void Alloc(int _len);
void Free();
int len;
double* val;
};
Array::Array(const Array& a) : len(a.len)
{
val = new double[len];
for (int i=0; i<len; i++)
val[i] = a.val[i];
}
Здесь Array::Array — конструктор, а Array::~Array — деструктор. Конструктор копирования (copy constructor) Array::Array(const Array&) вызывается при создании нового объекта, являющегося копией уже существующего объекта. Теперь объект класса Array нельзя испортить: как бы мы его ни создавали, что бы мы ни делали, его значение будет хорошим, потому что конструктор вызывается автоматически. Все опасные операции с указателями спрятаны в закрытые функции.
Array a(5); // вызывается Array::Array(int)
Array b; // вызывается Array::Array()
Array c(a); // вызывается Array::Array(const Array&)
Array d=a; // то же самое
b=c; // происходит вызов оператора =
// если он не определён (как в данном случае), то вызывается оператор присваивания по умолчанию, который
// осуществляет копирование базовых подобъектов и почленное копирование нестатических членов-данных.
// как правило конструктор копий и оператор присваивания переопределяются попарно
Оператор new тоже вызывает конструкторы, а delete — деструкторы.
По умолчанию, каждый класс имеет неявно объявленные конструктор без параметров, копирующий конструктор, копирующий оператор присваивания и деструктор.
Класс может иметь сколько угодно конструкторов (с разными наборами параметров), но только один деструктор (без параметров).
Другие возможности функций-членов
Функции-члены могут быть и операциями:class Array {
...
inline double &operator[] (int n)
{
return val[n];
}
И далее
Array a(10);
...
double b = a[5];
Функции-члены (и только они) могут иметь описатель const
class Array {
...
inline double operator[] (int n) const;
Такие функции не имеют права изменять поля класса (кроме полей, определённых как mutable). Если они пытаются это сделать, компилятор должен выдать сообщение об ошибке.
[править]
Наследование
Для создания классов с добавленной функциональностью вводят наследование. Класс-наследник имеет поля и функции-члены базового класса, но не имеет права обращаться к собственным (private) полям и функциям базового класса. В этом и заключается разница между собственными и защищёнными членами.
Класс-наследник может добавлять свои поля и функции или переопределять функции базового класса.
По умолчанию, конструктор наследника без параметров вызывает конструктор базового класса, а затем конструкторы нестатических членов-данных, являющихся экземплярами классов. Деструктор работает в обратном порядке. Другие конструкторы приходится определять каждый раз заново. К счастью, это можно сделать вызовом конструктора базового класса.
class ArrayWithAdd : public Array {
ArrayWithAdd(int n) : Array(n) {}
ArrayWithAdd() : Array() {}
ArrayWithAdd(const Array& a) : Array(a) {}
void Add(const Array& a);
};
Наследник — это больше чем базовый класс, поэтому, если наследование открытое, то он может использоваться везде, где используется базовый класс, но не наоборот.
Наследование бывает публичным, защищённым и собственным. При публичном наследовании, публичные и защищённые члены базового класса сохраняют свой статус, а к собственным не могут обращаться даже функции-члены наследника. Защищённое наследование отличается тем, что при нём публичные члены базового класса являются защищёнными членами наследника. При собственном наследовании все члены базового класса становятся собственными членами класса-наследника. Таким образом, пользователь производного класса не может обращаться к членам базового класса, даже если они объявлены как публичные. Класс-наследник делает их собственными с помощью собственного наследования. Как правило, публичное наследование встречается значительно чаще других.
Класс может быть наследником нескольких классов. Это называется множественным наследованием. Такой класс обладает полями и функциями-членами всех его предков. Например, класс FlyingCat (ЛетающийКот) может быть наследником классов Cat (Кот) и
FlyingAnimal (ЛетающееЖивотное)
class Cat {
...
void Purr();
...
};
class FlyingAnimal {
...
void Fly();
...
};
class FlyingCat : public Cat, public FlyingAnimal {
...
PurrAndFly() {Purr(); Fly();}
...
};
Полиморфизм
Полиморфизмом в программировании называется переопределение наследником функций-членов базового класса, например
class Figure {
...
void Draw() const;
...
};
class Square : public Figure {
...
void Draw() const;
...
};
class Circle : public Figure {
...
void Draw() const;
...
};
В этом примере, какая из функций будет вызвана —
Circle::Draw(),
Square::Draw()
или
Figure::Draw(),
определяется во время компиляции.
К примеру, если написатьFigure* x = new Circle(0,0,5);
x->Draw();
то будет вызвана Figure::Draw(), поскольку x — объект класса Figure. Такой полиморфизм называется статическим.
Но в C++ есть и динамический полиморфизм, когда вызываемая функция определяется во время выполнения. Для этого функции-члены должны быть виртуальными.
class Figure {
...
virtual void Draw() const;
...
};
class Square : public Figure {
...
virtual void Draw() const;
...
};
class Circle : public Figure {
...
virtual void Draw() const;
...
};
Figure* figures[10];
figures[0] = new Square(1, 2, 10);
figures[1] = new Circle(3, 5, 8);
...
for (int i = 0; i < 10; i++)
figures[i]->Draw();
В этом случае для каждого элемента будет вызвана
Square::Draw()
или
Circle::Draw()
в зависимости от вида фигуры.
Чисто виртуальной функцией называется функция-член, которая объявлена со спецификатором = 0:
class Figure {
...
virtual void Draw() const = 0;
);
Чисто виртуальная функция может быть оставлена без определения, кроме случая, когда требуется произвести её вызов. Абстрактным классом называется такой, у которого есть хотя бы одна чисто виртуальная функция-член. Объекты таких классов создавать запрещено. Абстрактные классы часто используются как интерфейсы.
Инкапсуляция
15 июня 2009 16:21
