Лекция 1. Знакомство с языком C++

Знакомство с языком C++. Сравнение традиционных и объектно ориентированных языков и промежуточное положение C++ в этой классификации. Классы, члены классов, методы. Конструктор по умолчанию и copy-конструктор. Переопределение операторов для классов на примере классов "вещественный вектор на плоскости" R2Vector и "матрица" Matrix. Правильное использование модификатора const и задание типов возвращаемых значений для разных методов и операторов; примеры дурного стиля.
Классы для поддержки двумерной графики (вектор, точка, прямоугольник).

Содержание лекции

• Знакомство с языком C++ и сравнение с другими языками
• Понятие класса
• Описание класса: интерфейс и реализация
• Члены класса
• Конструкторы и деструкторы
• Инициализация переменных в конструкторе
• Сколько конструкторов должно быть?
• Модификатор "const": константные ссылки и указатели, константные методы классов
• Прототипы методов: правильный выбор типов формальных аргументов и возвращаемых значений
• Переопределение операторов
• Библиотека классов для поддержки двумерной графики
• Особенности реализации
• Задачи по теме "Реализация классов на C++"

Предполагается, что читатель знаком с языком С. Язык C++ является развитием языка С и унаследовал от него большинство конструкций, так что грамотно написанная С-программа компилируется на С++ без всяких изменений. Разве что С++ исправляет некоторые ненормальности языка С. Например, несколько иначе трактуется понятие константы: в С++ описание

    const int N = 1000;

    #define N 1000

Иначе трактуется описание параметров функции: в C++ запись

    int f();

    int f(void);

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

Даже если вы предпочитаете оставаться в рамках языка C и не хотите использовать объектно ориентированные возможности C++, всегда лучше пользоваться компилятором C++ вместо C по следующим причинам.

1. В C++ более строгий и разумный контроль типов, чем в C.
2. Можно не пользоваться директивой препроцессора "#define", а вместо этого использовать "const int" в h-файлах.
3. В C++ можно описывать локальные переменные в любой точке программы, а не только в начале блока, как в C.
4. Комментарии в C++ "//..." гораздо удобнее, чем "/*...*/" в C.
5. В C++ появился настоящий логический тип "bool" и логические константы "true" и "false", в результате чего уже не приходится прибегать к фиктивному типу "BOOL", который в C задавался обычно с помощью директивы "#defile" или оператора "typedef" как один из целых типов, и к использованию целых констант с именами "TRUE" и "FALSE", которые тоже нужно было определять где-нибудь в h-файлах.

Что принципиально нового появилось в C++, чего не было в C? Конечно, это классы и все связанные с ними возможности объектно ориентированного программирования. Далее, это механизм исключений ("exception"), позволяющий удобным образом организовать обработку исключительных ситуаций и нелокальные переходы в программе. Наконец, это механизм шаблонов ("template"), позволяющий вводить типы, зависящие от параметров.

Изучая язык C++, следует всегда иметь в виду, что он не является "настоящим" объектно ориентированным языком (настоящие объектно ориентированные языки -- это, например, Java и C#). По своему положению C++ занимает промежуточное положение между объектно ориентированными и традиционными языками. Внешне C++ похож на объектно ориентированный язык, в нем присутствует главное понятие любого объектно ориентированного языка -- понятие класса и все связанное с этим (наследование, виртуальные методы и т.п.). Однако по способам размещения объектов в памяти C++ -- это традиционный язык. Поэтому часто C++ называют "объектно ориентированным Ассемблером". Более подробно эти различия рассмотрены в разделе "сравнение традиционных и объектно ориентированных языков"

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

Всегда следует различать описание класса, т.е. как бы "чертеж" класса, и конкретные объекты класса. Когда мы говорим "автомобиль Жигули 2106", что мы подразумеваем? Конкретный экземпляр или конструкцию и технологию производства? Под словом "класс" подразумевается обычно второе, т.е. описание класса. Как только описание класса готово, можно легко создавать объекты класса. Точно так же производство конкретного экземляра автомобиля не представляет особой сложности после завершения его разработки и организации производства. Разработка новой модели автомобиля обходится в сотни миллионов долларов, производство конкретного автомобиля -- в несколько тысяч.

В C++ объекты класса можно создавать двумя способами. Пусть мы имеем класс с именем "A". В C++ считается, что всякая переменная типа A содержит объект класса A. В этом принципиальное отличие языка C++ от объектно ориентированных языков! В объектно ориентированных языках (Java, C# и т.п.) переменные содержат не объекты, а хэндлы (handle) объектов, т.е. некоторую информацию, позволяющую получить доступ к объекту -- например, индекс объекта в некоторой глобальной таблице. Сами объекты расположены в "мире объектов", т.е. в специально организованной динамической памяти.

Итак, в C++, как только мы описываем переменную типа A, где A -- имя класса, сразу же создается объект, который располагается непосредственно в этой переменной. Описание

    A x;

Второй способ создания объекта заключается в использовании оператора "new". В этом случае объект создается в динамической памяти (ее называют также "кучей", heap). Оператор "new" возвращает указатель на созданный объект (т.е. просто его адрес). Обычно этот указатель запоминается в переменной типа "указатель на класс A":

    A* p = new A;

Созданный таким образом объект никогда не удаляется автоматически! Программист в нужный момент должен сделать это сам, используя оператор "delete":

    delete p;

Описание класса в C++ состоит из двух частей: описание интерфейса и реализация методов класса. Традиционно описание интерфейса класса помещается в заголовочный файл (h-файл), имя такого файла имеет расширение ".h". Описание интерфейса содержит описание переменных-членов класса и описание прототипов методов. Впрочем, некоторые простые методы могут быть реализованы непосредственно в h-файле; такую реализацию называют "внутристроковой" или "инлайновой" (inline). (Русский термин "внутристроковая" совершенно не прижился, и все русскоязычные программисты употребляют термин "инлайновая", так что если хотите, чтобы вас понимали, говорите на программистском языке.) При использовании инлайновых методов и функций их текст непосредственно вставляется в то место, где он используется, подобно макроопределениям в Ассемблере. (Вспомним, что C++ -- это объектно ориентированный Ассемблер!) Объем кода при этом увеличивается (один и тот же фрагмент повторяется многократно при каждом использовании), зато программа получается значительно более быстрой: во первых, не используется механизм вызова функций; во вторых, и самое главное, -- компилятор C++ получает возможность оптимизации кода, которая не ограничивается рамками одного метода.

Реализация объемных (не инлайновых) методов класса выносится из заголовочного файла в файл реализации, который называют C++ файлом. К сожалению, в отличие от h-файлов программисты не сумели договориться между собой о стандартном расширении для C++ файлов. В разных операционных системах и разных системах разработки используются расширения ".cpp", ".cxx", ".cc" и другие. Стандарт языка не устанавливает никаких явных правил на этот счет. Обычно все конкретные компиляторы понимают по умолчанию перечисленные выше расширения как расширения файлов, содержащих программы на C++. Но компилятор можно явным образом заставить трактовать программу как программу на C++ независимо от расширения файла. Например, в случае компилятора "gcc" можно использовать ключ "-x":

    gcc -x c++ ...

    cl /TP ...

Мы будем использовать расширение ".cpp" для файлов, содержащих реализацию классов и функций на C++. Кроме реализации методов и функций, cpp-файлы содержат также

• задание глобальных и статических переменных. Так, если в h-файле описана, например, глобальная переменная "max_ind" как внешняя

      extern int max_ind;
  

  то в cpp-файле она должна быть описана без модификатора "extern":

      int max_ind = 0;
  

  кроме того, всегда следует задавать какие-либо начальные значения для глобальных и статических переменных прямо при их описании. Поэтому мы присваиваем глобальной переменной max_ind значение 0;
• задание статических членов классов. Подробнее статические члены и методы классов будут рассмотрены в лекции 3.

Члены класса -- это переменные, содержащиеся внутри каждого объекта класса, как бы входящие в "конструкцию" класса. (Мы не рассматриваем пока статические члены класса.) Описание членов класса содержится в описании интерфейса класса, которое помещается в h-файл. Каждый член класса имеет имя. Описания членов класса имеют точно такой же вид, как и описания обычных переменных в языке C. Отличие только в том, что они содержатся внутри описания класса. Рассмотрим пример. Пусть класс R2Vector представляет собой вектор на двумерной плоскости. Вектор задается двумя вещественными координатами x, y. Описание класса выглядит так:

    class R2Vector {
    public:
        double x;
        double y;
        . . .
    };

При создании объекта класса его члены инициализируются с помощью специального метода, который называется конструктором. Исполняющая система C++ сначала захватывает область памяти под объект (в стеке или в куче, в зависимости от того, как создается объект). Затем вызывается конструктор объекта, которому передается адрес этой области памяти. Назначение конструктора -- установить начальные значения членов класса, а также выполнить необходимые начальные действия при создании объекта. Имя конструктора совпадает с именем класса. Конструктор может иметь аргументы, может быть несколько конструкторов с разными наборами аргументов.

Аналогично при удалении объекта вызывается специальный метод, который называется деструктором. Деструктор вызывается непосредственно перед освобождением памяти, занятой объектом. Крайне дурным стилем является выполнение каких-либо содержательных действий в деструкторе! Например, сохранение информации в файле на диске не следует помещать в деструктор, для этого используют специальный метод вроде "save". В деструкторе чаще всего выполняется только одно действие: освобождение динамической памяти, захваченной в конструкторе или в других методах класса. Делается это тогда, когда объект класса содержит указатели на области динамической памяти.

    class Matrix {
        const int n;
        const int m;
        double* elements;
    public:
        Matrix(int rows, int columns):
            n(rows),
            m(columns),
            elements(new double[n * m])
        {
            for (int i = 0; i < n*m; i++)
                elements[i] = 0.;
        }

        ~Matrix() { delete[] elements; }

        . . .
    };

Основная проблема для начинающих при программировании на C++ -- это отсутствие однозначных решений. Примерно одинакового результата можно достичь десятками различных способов. Причем ни в одном компилятор не выдает сообщений об ошибках, и программа работает правильно. Однако на поверку оказывается, что, например, при некорректных решениях программа замедляется в сотни раз или исхоный код невозможно использовать другим программистам (достаточно, к примеру, опустить модификатор "const", и метод уже нельзя использовать для константных объектов). Из многих возможных решений обычно только одно правильное, остальные -- это дурной стиль. Так что опыт программиста на C++ -- это прежде всего умение из множества различных возможных решений выбрать единственное правильное, т.е. избежать дурного стиля. Мы будем часто приводить примеры дурного стиля, чтобы потом было легче избежать их. Примеры дурного стиля будут обводиться красной рамкой.

Рассмотрим подробнее описание и реализацию конструкторов. Здесь нужно соблюдать следующие 2 неформальных, но очень важных правила.

1. Все переменные-члены класса должны быть инициализированы в конструкторе, подчеркиваем, все! Если их даже 1000 и инициализация большинства по смыслу не нужна, все равно их все надо тупо выписать в том порядке, в котором они описаны в интерфейсе класса, и присвоить им некоторые начальные значения.
2. Инициализацию всегда следует выполнять не внутри тела конструктора, а в списке инициализации.

Список инициализации располагается между заголовком конструктора, после которого ставится двоеточие, и телом конструктора, которое начинается с открывающей фигурной скобки. Рассмотрим, например, конструктор по умолчанию (т.е. без аргументов) упомянутого выше класса R2Vector. Если реализация инлайновая, т.е. внутри описания класса в h-файле, то она должна выглядеть так:

    R2Vector():
        x(0.),
        y(0.)
    {}

    R2Vector::R2Vector():
        x(0.),
        y(0.)
    {}

R2Vector::R2Vector() {
    x = 0.;
    y = 0.;
}

Вернемся еще раз к рассмотренному выше классу Matrix. В конструкторе этого класса инициализируются константные члены "n" и "m" и указатель на массив элементов матрицы "elements":

    Matrix(int rows, int columns):
        n(rows),
        m(columns),
        elements(new double[n * m])
    {
        for (int i = 0; i < n*m; i++)
            elements[i] = 0.;
    }

class Matrix {
    const int n;
    const int m;
    double* elements;
public:
    Matrix(int rows, int columns) {
        n = rows;
        m = columns;
        elements = new double[n * m];
        for (int i = 0; i < n*m; i++)
            elements[i] = 0.;
    }
    . . .

Для простых классов, описывающих объекты, которые можно легко создавать и копировать, должно быть по крайней мере 3 конструктора.

1. Конструктор без параметров, или конструктор "по умолчанию" (default constructor). Именно он вызывается, когда создается простая переменная или массив. Например, пусть мы имеем класс с именем "A", в котором определен конструктор по умолчанию. Тогда при описании

       A x;
   

   конструктор по умолчанию вызывается для объекта, который размещается в переменной x. Точно так же он вызывается, когда объект создается в динамической памяти с помощью оператора "new":

       A* p = new A;
   

   или

       A* p = new A();
   

   (в C++ обе записи допустимы и эквивалентны). При создании массива элементов типа "A" default-конструктор вызывается для каждого элемента создаваемого массива:

       A v[100];
   

   аналогично default-конструктор вызывается и при создании массива в динамической памяти:

       A* w = new A[100];
   

   В обоих случаях default-конструктор будет вызван 100 раз. Отметим, что в последнем случае при освобождении памяти, занятой массивом, который был создан в динамической памяти, надо использовать векторную форму оператора "delete":

       delete[] w;
   

   При уничтожении массива деструктор вызывается для каждого элемента массива (в нашем случае -- 100 раз).

2. Копирующий конструктор (copy-constructor). В качестве аргумента copy-конструктору передается объект, с которого нужно сделать копию. Прототип copy-конструктора для класса "A" выглядит следующим образом:

       A(const A& x);
   

   Эта запись означает, что copy-конструктору передается константная ссылка на объект "x". Тип данных "ссылка" появился в C++, его не было в языке C. Ссылка описывается с помощью значка "&", не следует путать его с операцией взятия адреса, никакой связи нет! По механизму реализации ссылка похожа на указатель -- физически ссылка представляется адресом памяти, так же как и указатель. Однако, в отличие от указателя, в случае ссылки для доступа к объекту не надо использовать операцию косвенной адресации "*" (dereference). Ссылка используется так же, как и сам объект. Логически ссылку следует понимать как второе имя или как псевдоним объекта. Объект, на который указывает ссылка, должен быть задан при описании ссылки. Например, следующее описание ошибочно:

       A& x;
   

   Ошибка: при описании ссылки следует задать объект, на который она указывает.
   Правильное описание может выглядеть, например, так:

       A y;
       A& x = y;
   

   Переменные "y" и "x" после этого описания используются как различные имена для одного и того же объекта. В отличие от указателя, ссылку уже нельзя перенаправить на другой объект; ссылка навеки связана с объектом, который был задан при ее описании.

   Ссылки в C++ почти исключительно используются для передачи аргументов функциям и методам, а также для возврата значений. Константная ссылка в C++, так же как и константный указатель в C, означает, что объект запрещено изменять (т.е. константность ссылки гарантирует, что объект не будет испорчен при передаче ссылки на него в качестве аргумента).

3. Наконец, почти всегда у класса должен быть какой-нибудь содержательный конструктор, который создает объект с заданными свойствами. Аргументы конструктора задают свойства создаваемого объекта. Набор аргументов в каждом случае зависит от специфики описываемого класса.

Для примера рассмотрим еще раз упомянутый выше класс R2Vector, моделирующий вектор на двумерной плоскости. У него 3 конструктора: конструктор по умолчанию, copy-конструктор и конструктор, создающий вектор по двум его координатам:

class R2Vector {
public:
    double x;
    double y;

    // Default-constructor
    R2Vector():     
        x(0.),
        y(0.)
    {}

    // Copy-constructor
    R2Vector(const R2Vector& v):
        x(v.x),
        y(v.y)
    {}

    // Constructor creating a vector by coordinates
    R2Vector(double coordX, double coordY):
        x(coordX),
        y(coordY)
    {}

    . . .
};

При описании переменных, методов классов, формальных аргументов и возвращаемых значений исключительно важно правильно использовать модификатор "const".

Особенность применения модификатора const: его можно либо не использовать вообще (так поступили, например, создатели языка Java), либо всюду использовать его правильно. Применение "const" совершенно не совместимо с ошибками и дурным стилем! Коль скоро вы его применяете, вам приходится применять его всюду правильно, иначе в лучшем случае вы не сможете скомпилировать программу (это по меньшей мере заставит вас исправить ошибки), в худшем случае компилятор не сможет отследить ошибку (вернее, дурного стиля), и вашими классами никто не сможет пользоваться.

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

Адрес константного объекта можно помещать лишь в указатель на константный объект. Проиллюстрируем на примере, как в C и C++ описывается указатель на константу:

    const int *p;

    int x;
    int * const p = &x;

Константные методы классов -- это те методы, которые гарантированно не меняют объекта, к которому они применяются. К константным объектам можно применять лишь константные методы. Константный метод задается с помощью модификатора "const", который записывается после круглых скобок, содержащих параметры метода. Например, для класса R2Vector метод "length", вычисляющий длину вектора, является константным. Описание его прототипа в h-файле выглядит так:

    class R2Vector {
        . . .
        double length() const;
        . . .
    };

    double R2Vector::length() const {
        return sqrt(x*x + y*y);
    }

Как правило, все методы, которые выдают какие-либо характеристики объекта, должны быть описаны как константные. В противном случае их нельзя будет применить для константных объектов или даже для нормальных объектов, доступ к которым осуществляется через константный указатель или ссылку! Обычная ошибка начинающих: забывают записать модификатор "const" в описании прототипа метода, который по своей сути не меняет объект. Например, отсутствие "const" в описании прототипа метода "length()" является крайне дурным стилем.

class R2Vector {
    . . .
    double length() {
        return sqrt(x*x + y*y);
    }
    . . .
};

Бывают, однако, и менее очевидные ошибки. Не забывайте о следующей возможности C++: может быть несколько одинаковых методов одного и того же класса, но с разными формальными параметрами -- как иногда говорят, с разной сигнатурой. Это знают все без исключения программисты на C++, однако не все помнят, что модификатор "const" также включается в сигнатуру метода! Это означает, что у класса могут быть два метода, которые отличаются только модификатором "const"; например, такая запись вовсе не является ошибкой:

    class A {
        . . .
        int f();
        int f() const;
        . . .
    };

    A x;
    const A y;
    . . .
    int res1 = x.f();
    int res2 = y.f();

Часто встречающаяся ошибка состоит в том, что в некоторых ситуациях забывают задать константный вариант метода, ограничиваясь только обычным вариантом. Рассмотрим пример с классом "Matrix". Пусть у него будет метод "at", который возвращает ссылку на элемент матрицы с заданными индексами. С его помощью элемент матрицы "a" с индексами i, j записывается как "a.at(i,j)". Дурной стиль состоит в том, что забывают реализовать два метода "at", обычный и константный, ограничиваясь только обычным методом.

class Matrix {
    const int n;
    const int m;
    double* elements;
public:
    . . .
    double& at(int i, int j) {
        return elements[i*m + j];
    }
    // Больше методов с именем "at" нет
    . . .
};

    class Matrix {
        . . .
        double& at(int i, int j) {
            return elements[i*m + j];
        }
        const double& at(int i, int j) const {
           return elements[i*m + j];
        }
 
        /* или
        double at(int i, int j) const {
            return elements[i*m + j];
        }
        */
        . . .
    };

    class Matrix {
        const int n;
        const int m;
        double* elements;
    public:
        . . .
        double& at(int i, int j) {
            return elements[i*m + j];
        }
        double at(int i, int j) const {
            return elements[i*m + j];
        }
        double* operator[](int i) {
            return elements + i*m;
        }
        const double* operator[](int i) const {
            return elements + i*m;
        }
        . . .
    };

Подведем итог:

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

Владение языком C++ состоит прежде всего в умении правильно выбрать типы аргументов и возвращаемых значений методов, т.е. правильно написать прототипы методов. К сожалению, компилятор позволяет сделать это десятками способов, не выдавая сообщений об ошибках. Между тем правильный способ почти всегда единственный, остальные -- это дурной стиль. Рассмотрим типичные ошибки на примере класса R2Vector и методов сложения двух векторов ("operator+") и увеличения вектора на другой вектор ("operator+=").

    R2Vector a, b, c;
    . . .
    c = a + b;
    a += b;

    c = a + b;

    c = a.operator+(b);

    a.operator+=(b);

Рассмотрим, какие ошибки можно сделать, определяя прототип метода "operator+" для класса R2Vector. Первое, совсем неправильное решение:

    R2Vector operator+(R2Vector a, R2Vector b);

Впрочем, следующее решение не намного лучше:

    R2Vector operator+(R2Vector b);

    R2Vector operator+(R2Vector& b);

    R2Vector operator+(const R2Vector& b);

    R2Vector operator+(const R2Vector& b) const;

class R2Vector {
    . . .
    R2Vector operator+(R2Vector a, R2Vector b);
    // Неправильно! Два аргумента вместо одного

    R2Vector operator+(R2Vector b);
    // Неправильно! Передается копия аргумента вместо ссылки

    R2Vector operator+(R2Vector& b);
    // Неправильно! Используется обычная ссылка на аргумент
    //              вместо константной ссылки

    R2Vector operator+(const R2Vector& b);
    // Неправильно! Метод не объявлен как константный

    // Правильное решение:
    R2Vector operator+(const R2Vector& b) const;
    . . .
};

Рассмотрим теперь оператор "увеличить на" ("operator+=") применительно к классу R2Vector. Не будем выписывать множества неправильных решений, сразу укажем правильное:

class R2Vector {
    . . .
    R2Vector& operator+=(const R2Vector& b);
    . . .
};

1. Этот метод изменяет объект, к которому применяется (увеличивает вектор, к которому применяется, на вектор, передаваемый в качестве аргумента), и поэтому не является константным.
2. В результате выполнения этого метода не создается нового объекта (в отличие от метода "operator+", который создает новый вектор, равный сумме двух операндов). Поэтому тип возвращаемого значения является ссылкой на класс R2Vector, которая на самом деле указывает на объект, к которому применяется метод. Реализация метода должна оканчиваться строкой

           return *this;
   

    class R2Vector {
    public:
        double x;
        double y;
        . . .
        R2Vector operator+(const R2Vector& b) const {
            return R2Vector(x + b.x, y + b.y);
        }

        R2Vector& operator+=(const R2Vector& b) {
            x += b.x;
            y += b.y;
            return *this;
        }
        . . .
    };

Суммируем вышесказанное в виде краткого набора правил, которые следует соблюдать при написании прототипов методов.

1. В качестве аргументов следует передавать не сами объекты, а ссылки на них. Ссылка должна быть константной, если аргумент не меняется в результате выполнения метода. (Замечание: в отличие от классов, объекты базовых типов -- "int", "double" и т.п. лучше передавать по значению, а не по ссылке -- конечно, только в том случае, когда аргумент не должен изменяться.) Пример для класса R2Vector:

       R2Vector operator+(const R2Vector& v) const;
   

2. Метод должен быть описан как константный, если он не изменяет объекта, к которому применяется. Пример для класса R2Vector:

       double length() const;
   

3. Метод, осуществляющий доступ к внутренним элементам объекта класса (например, метод, осуществляющий доступ к элементу матрицы с заданными индексами), должен быть определен в двух вариантах: обычном и константном. Обычный вариант не содержит модификатора "const" после списка формальных аргументов и возвращает обычную ссылку или обычный указатель на нужный элемент объекта. Константный вариант метода описывается с помощью модификатора "const" после формальных аргументов и возвращает либо константную ссылку или константный указатель, либо просто значение нужного элемента. Пример для класса Matrix:

       double& at(int i, int j);
       double at(int i, int j) const;
   

4. Метод, создающий новый объект в результате его выполнения, должен возвращать этот объект в качестве результата; таким образом, тип возвращаемого значения -- это просто имя класса. Чаще всего такой метод не изменяет объекта, к которому применяется, и потому должен быть описан как константный. Метод, изменяющий объект, к которому он применяется, и возвращающий измененный объект, не является константным и должен возвращать значение типа "ссылка на класс", к которому он принадлежит. Реализация такого метода заканчивается строкой "return *this;". Примеры для класса R2Vector:

       R2Vector operator+(const R2Vector& v) const;
       R2Vector& operator+=(const R2Vector& v);
   

Заголовочный файл "R2Graph.h" включает в себя определение и инлайновую реализацию следующих классов:

R2Vector

двумерный вектор с вещественными координатами;

R2Point

точка на двумерной плоскости с вещественными координатами;

R2Rectangle

прямоугольник на двумерной плоскости с вещественными координатами;

I2Vector

двумерный вектор с целочисленными координатами;

I2Point

точка на двумерной плоскости с целочисленными координатами;

I2Rectangle

прямоугольник на двумерной плоскости с целочисленными координатами.

Класс R2Vector был рассмотрен достаточно подробно выше. Реализация класса I2Vector почти ничем не отличается, только вместо вещественных координат x, y используются целочисленные x, y.

Класс R2Point (точка с вещественными координатами) очень похож на R2Vector, однако стоит отметить следующие отличия:

• разность двух точек является вектором, а не точкой! Соответственно, прототип метода вычитания для точек выглядят следующим образом:

      R2Vector operator-(const R2Point& p) const;
  

• к точке можно прибавить (или вычесть) вектор и получить точку:

      R2Point operator+(const R2Vector& v) const;
      R2Point& operator+=(const R2Vector& v);
      R2Point operator-(const R2Vector& v) const;
      R2Point& operator-=(const R2Vector& v);
  

Класс "Прямоугольник с вещественными координатами" R2Rectangle задается его левым нижним углом, шириной и высотой:

class R2Rectangle {
    double l;   // left
    double b;   // bottom
    double w;   // width
    double h;   // height
    . . .

public:
    double left() const { return l; }
    double right() const { return l + w; }
    double bottom() const { return b; }
    double top() const { return b + h; }
    double width() const { return w; }
    double height() const { return h; }

    void setLeft(double left) { l = left; }
    void setBottom(double bottom) { b = bottom; }
    void setWidth(double width) { w = width; }
    void setHeight(double height) { h = height; }

В математике ось Y направлена снизу вверх, в программировании же в случае целочисленных, или пиксельных, координат ось Y направлена сверху вниз. (Заметим, что в режимах, где используются координаты в реальных единицах, например в миллиметрах, ось Y имеет направление как в математике -- снизу вверх.) При определении целочисленного прямоугольника I2Rectangle учитывается эта особенность пиксельной системы координат. Целочисленный прямоугольник задается координатами его левого верхнего угла, шириной и высотой (в отличие от вещественного прямоугольника, который задается левым нижним углом).

class I2Rectangle {
    // Y-coordinate axis in case of I2Rectangle goes down, so that
    // y-coordinate of top is less than y-coordinate of bottom
    int l;      // left
    int t;      // top
    int w;      // width
    int h;      // height
    . . .

    int bottom() const { return t + h; }
    int top() const { return t; }

    void setLeft(int left) { l = left; }
    void setTop(int top) { t = top; }

Задачи по теме "Реализация классов на C++".

Конец лекции