Определения класса
Определения класса
Классы определяются в С++ аналогично тому, как это делается в Java и C#, однако надо иметь в виду, что существует несколько отличий. Мы рассмотрим эти отличия на нескольких примерах. Начнем с класса, представляющего пару координат (x, у):
01 #ifndef POINT2D_H
02 #define POINT2D_H
03 class Point2D
04 {
05 public:
06 Point2D() {
07 xVal = 0;
08 yVal = 0;
09 }
10 Point2D(double x, double у) {
11 xVal = x;
12 yVal = у;
13 }
14 void setX(double x) { xVal = x; }
15 void setY(double у) { yVal = у; }
16 double x() const { return xVal; }
17 double y() const { return yVal; }
18 private:
19 double xVal;
20 double yVal;
21 };
22 #endif
Представленное выше определение класса обычно оформляется в виде заголовочного файла, типичным названием которого может быть point2d.h. В этом примере проявляются следующие характерные особенности С++:
• Определение класса разделяется на секции (открытую, защищенную и закрытую) и заканчивается точкой с запятой. Если не указано ни одной секции, по умолчанию используется закрытая секция. (Для совместимости с языком С в С++ предусмотрено ключевое слово struct, идентичное классу с тем исключением, что по умолчанию используется открытая секция).
• Данный класс имеет два конструктора (один без параметров и другой с двумя параметрами). Если в классе вообще не объявляется конструктор, С++ автоматически добавляет конструктор без параметров и с пустым телом.
• Функции, получающие данные, x() и y(), объявляются как константные. Это значит, что они не будут (и не смогут) модифицировать переменные—члены или вызывать неконстантные функции—члены (например, setX() и setY().)
Указанные выше функции реализовывались бы как встроенные функции, являющиеся частью определения класса. Альтернативный подход заключается в предоставлении в заголовочном файле только прототипов функций и реализации функций в файле .cpp. В этом случае заголовочный файл имел бы следующий вид:
01 #ifndef POINT2D_H
02 #define POINT2D_H
03 class Point2D
04 {
05 public:
06 Point2D();
07 Point2D(double x, double у);
08 void setX(double x);
09 void setY(double у);
10 double x() const;
11 double y() const;
12 private:
13 double xVal;
14 double yVal;
15 };
16 #endif
Реализация функций выполнялась бы в файле point2d.cpp:
01 #include "point2d.h"
02 Point2D::Point2D()
03 {
04 xVal = 0.0;
05 yVal = 0.0;
06 }
07 Point2D::Point2D(double x, double у)
08 {
09 xVal = x;
10 yVal = у;
11 }
12 void Point2D::setX(double x)
13 {
14 xVal = x;
15 }
16 void Point2D::setY(double у)
17 {
18 yVal = у;
19 }
20 double Point2D::x() const
21 {
22 return xVal;
23 }
24 double Point2D::y() const
25 {
26 return yVal;
27 }
Этот файл начинается с включения заголовочного файла point2d.h, потому что прежде чем компилятор будет выполнять синтаксический анализ реализаций функций—членов, он должен иметь определение класса. Затем идут реализации функций, перед именем которых через оператор :: указывается имя класса.
Мы узнали, как можно реализовать встроенную функцию и как можно реализовать ее в файле .cpp. Семантически эти два подхода эквивалентны, однако при вызове встроенной функции большинство компиляторов просто разворачивают тело функции вместо формирования реального вызова функции. Обычно это ведет к получению более быстрого кода, но может увеличить размер приложения. По этой причине только очень короткие функции следует делать встроенными; длинные функции всегда следует реализовывать в файле .cpp. Кроме того, если мы забудем реализовать какую-нибудь функцию и попытаемся ее вызвать, компоновщик «пожалуется» на существование неразрешенного символа.
Теперь попытаемся использовать этот класс.
01 #include "point2d.h"
02 int main()
03 {
04 Point2D alpha;
05 Point2D beta(0.666, 0.875);
06 alpha.setX(beta.y());
07 beta.setY(alpha.x());
08 return 0;
09 }
В С++ переменные любого типа можно объявлять без непосредственного использования оператора new. Первая переменная инициализируется с помощью стандартного конструктора Point2D (т.е. конструктора без параметров). Вторая переменная инициализируется с использованием второго конструктора. Обращение к члену объекта осуществляется с использованием оператора . (точка).
Объявленные таким образом переменные ведут себя как элементарные типы Java и C# (такие, как int и double). Например, при использовании оператора присваивания копируется содержимое переменной, а не ссылка на объект. И если позже переменная будет модифицирована, значение всех других переменных, к которым присваивалась первая переменная, не изменится.
С++, как объектно—ориентированный язык, поддерживает наследование и полиморфизм. Для иллюстрации этих свойств мы рассмотрим пример абстрактного класса Shape (фигура) и подкласса Circle (окружность). Начнем с базового класса:
01 #ifndef SHAPE_H
02 #define SHAPE_H
03 #include "point2d.h"
04 class Shape
05 {
06 public:
07 Shape(Point2D center) { myCenter = center; }
08 virtual void draw() = 0;
09 protected:
10 Point2D myCenter;
11 };
12 #endif
Определение класса создается в заголовочном файле с именем shape.h. Поскольку в этом определении делается ссылка на класс Point2D, мы включаем заголовочный файл point2d.h.
Класс Shape не имеет базового класса. В отличие от Java и C#, в С++ не предусмотрен обобщенный класс Object, который наследуется всеми другими классами. Qt предоставляет QObject в качестве естественного базового класса для объектов всех типов.
Объявление функции draw() имеет две интересные особенности. Она содержит ключевое слово virtual и завершается равенством = 0. Ключевое слово virtual означает, что данная функция может быть переопределена в подклассах. Подобно C# функции—члены в С++ по умолчанию не могут переопределяться. Странное приравнивание = 0 указывает на то, что данная функция — чисто виртуальная функция, которая не имеет реализации по умолчанию, и она должна быть реализована в подклассах. Концепция «интерфейса» в Java и C# соответствует в С++ классу, содержащему только чисто виртуальные функции.
Ниже приводится определение подкласса Circle:
01 #ifndef CIRCLE_H
02 #define CIRCLE_H
03 #include "shape.h"
04 class Circle : public Shape
05 {
06 public:
07 Circle(Point2D center, double radius = 0.5)
08 : Shape(center) {
09 myRadius = radius;
10 }
11 void draw() {
12 // здесь выполняются какие-то действия
13 }
14 private:
15 double myRadius;
16 };
17 #endif
Класс Circle наследует класс Shape в открытой форме, т.е. все открытые члены класса Shape остаются открытыми в Circle. С++ поддерживает также защищенное и закрытое наследование, которое ограничивает доступ к открытым и защищенным членам базового класса.
Конструктор принимает два параметра. Второй параметр необязателен, по умолчанию он принимает значение 0.5. Конструктор передает параметр center конструктору базового класса, для чего используется специальный синтаксис списка инициализации между сигнатурой функции и телом функции. В теле функции мы инициализируем переменную—член myRadius. Инициализацию этой переменной можно было сделать в той же строке, где инициализируется конструктор базового класса:
Circle(Point2D center, double radius = 0.5)
: Shape(center), myRadius(radius) { }
С другой стороны, С++ не позволяет инициализировать переменную—член в определении класса, поэтому следующий программный код неверен:
// НЕ БУДЕТ КОМПИЛИРОВАТЬСЯ
private:
double myRadius = 0.5;
};
Сигнатура функции draw() совпадает с сигнатурой виртуальной функции draw(), определенной в классе Shape. Она здесь переопределяется и будет вызываться полиморфно, когда draw() вызывается экземпляром Circle через ссылку или указатель на Shape. С++ не имеет ключевого слова override, доступного в C#. С++ также не имеет ключевых слов super и base, ссылающихся на базовый класс. Если требуется вызвать базовую реализацию функции, можно перед именем функции указать имя базового класса и оператор ::. Например:
01 class LabeledCircle : public Circle
02 {
03 public:
04 void draw() {
05 Circle::draw();
06 drawLabel();
07 }
08 };
С++ поддерживает множественное наследование, т.е. возможность создавать класс, производный сразу от нескольких других классов. При этом используется следующий синтаксис:
class DerivedClass : public BaseClass1, public BaseClass2, …,
public BaseClassN
{
…
};
По умолчанию функции и переменные, объявленные в классе, связываются с экземплярами этого класса. Мы можем объявлять статические функции—члены и статические переменные—члены, которые могут использоваться без экземпляра. Например:
01 #ifndef TRUCK_H
02 #define TRUCK_H
03 class Truck
04 {
05 public:
06 Truck() { ++counter; }
07 ~Truck() { --counter; }
08 static int instanceCount() { return counter; }
09 private:
10 static int counter;
11 };
12 #endif
Статическая переменная—член счетчика counter отслеживает количество экземпляров truck, которые существуют в любой момент времени. Конструктор truck его увеличивает на единицу. Деструктор, опознаваемый по префиксу ~, уменьшает счетчик на единицу. В С++ деструктор автоматически вызывается, когда статически распределенная переменная выходит из области видимости или когда удаляется переменная, память для которой выделяется при помощи оператора new. Это аналогично тому, что делается в методе finalize() в Java, за исключением того, что мы можем рассчитывать на его вызов в определенный момент времени.
Статическая переменная—член существует в единственном экземпляре для класса — такие переменные являются «переменными класса», а не «переменными экземпляра». Каждая статическая переменная—член должна определяться в файле .cpp (но без повторения ключевого слова static). Например:
#include "truck.h"
int Truck::counter = 0;
Если этого не сделать, компоновщик выдаст сообщение об ошибке из-за наличия «неразрешенного символа». Обращаться к статической функции instanceCount() можно за пределами класса, указывая имя класса перед ее именем. Например:
01 #include <iostream>
02 #include "truck.h"
03 using namespace std;
04 int main()
05 {
06 Truck truck1;
07 Truck truck2;
08 cout << Truck::instanceCount() << " equals 2" << endl;
09 return 0;
10 }