Объектно-ориентированные особенности языка

Си++ добавляет к Си объектно-ориентированные возможности. Он вводит классы, которые обеспечивают три самых важных свойства ООП: инкапсуляцию, наследование и полиморфизм.

 

12. СИ++ как СИ с классами. Определение класса. Конструкторы и деструкторы

Класс С++ -тип структуры, позволяющий включать в описание не только элементы, содержащие значения, но и функции, оперирующие этими значениями. В С++ вводится специальная терминология: данные получили название член-данные, а функции – член-функции (методы). Для реализации введем точки с плоскости в декартовой системе координат.

class Point2D

{

private:

double a,b;

public:

void read();

double mod() count

{

return sqrt(x*x+y*y);

}

void print() const;

Имя типа Point2D будет представлять новый тип данных. Это имя может быть использовано для объявления переменных этого нового типа. Эти переменные называются объектами.

void main()

{

Point2D p1,p2;

}

Тело класса, заключенное в фигурные скобки и ограниченное точками с запятой содержит … Члены класса можно разделить на две группы:

1. Член данные – данные, характеризующие описываемую абстракцию
2. Член функции – действия, функции или операции, которые могут быть выполнены над переменными этого типа.

В нашем примере для описания класса используются слова public и private. Кроме этих слов еще может быть слово protected. Эти слова управляют доступом к членам класса. Подобные ограничение доступа носит название сокрытие информации. Ключевое слово protected ограничивает использование член данных потомками базового класса при наследовании. В нашем случае эти слова эквивалентны. Хорошим стилем программирования считается объявление функций в части public, а данных в private. При этом обеспечивается защита член данных класса от случайных изменений и несанкционированного доступа. При необходимости корректировки член данных, изменения надо проводить только в функциях, которые являются только членами этого класса. Если при объявлении класса эти слова опущены. то подразумевается доступ private. Поэтому в данном примере слово private можно было опустить

class Point2D

{

private:

double x,y; //+ еще Point2D *const this;

 

public:

double mod()const

{

return (sqrt(x*x+y*y));

}

void read(); //Point2D *this

void print()const;

};

Метод mod определяется прямо при описании класса. Подобные методы по умолчанию считаются встроенными, т.е. inline. Два других типа требуют определения. Обычно для таких методов создаются файлы с расширением cpp.

При определении метода вне класса имя функции в заголовке определения должно быть уточнено именем класса с помощью бинарной операции расширения области видимости (::)

//Point2D.cpp

#include <iostream.h>

#include <math.h>

#include “point2d.h”

/*имя_класса::имя_член_функции*/

void Point2D::read()

{

cout<<”Точка:”;

cin>>x>>y;

}

void Point2D::print()const

{

cout<<”Точка: ”<<x<<” “<<y<<”\n”;

};

Если при определении член функции используется ключевое слово inline, то такая функция будет явно встраиваемой. При определении член-функции класса доступ к другим членам класса без использования операции уточнения (“->” и “.”). Это вызвано тем, что всем член-функциям передается неявный элемент – указатель на объект класса, для которого данная функция вызывается (this). Поэтому все неуточненные член-функции неявно уточняются этим указателем. (my_class *const this).

Для функции со спецификатором const, this имеет следующий вид: const my_class *const this.

//main.cpp

#include <iostream.h>

#include “point2d.h”

Point2D p0; //определен статически. Статические данные заполняются нулями.

void main()

{

Point2D p1,

*p2=new Point2D,

&p3=*new Point2D; //будет находиться мусор

 

p1.read();

p2->read();

p3.read();

cout<<p1.mod()<<” “<<p2->mod()<<” “<<p3.mod()<<”\n”;

 

delete p2;

delete &p3;

};

//язык программирования С

class Point2D

{

double x,y;

 

double mod(const point2D *this)

{

return (sqrt(this->x*this->x+this->y*this->y));

}

 

void print()

{

...

}

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

Point2D(double, double)

Point2D::Point2D(double x, double y)

{ x=_x;

y=_y;}

//main.cpp

Poind2D p10=Point2d(1,2);

p20=Poind2D(2,2);

Poind2D p10(1,2), p20(2,2); //большинство программистов используют сокращенную запись. Происходит 2 действия: выделение физической памяти и вызов специальной функции для помещения в память начального значения.

Т.к. член-функции представляются собой функцию, но с ограниченной областью видимости (внутри класса0 на них распространяются все правила, определенные для функции, в частности они могут быть перегружаемыми. Т.е. в определении класса может быть объявлено несколько функции с одним и тем же именем, но с разной сигнатурой. Все сказанное относится и к конструкторам.

//point2d.h

Poind2D(double a=0)

{

x=a;

y=a;

}

Poind2D p1, p2(2); //вызовется конструктор без параметров

Point2D p3(5,6) //вызовется с 2 параметрами

p4=4.0; //с одним параметром

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

Конструкторы могут быть перегружаемыми, а значит содержать любое количество элементов. Деструктор для каждого класса может быть только один и не должен содержать аргументов.

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

Конструктор по умолчанию-это конструктор, вызывающийся без параметров

Деструкор-это особый вид метода, применяющийся для освобождения памяти

 

Перегрузка операций

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

возвр.значение имя_класса::operator#(список_аргументов)

{

//выполняемые_действия...

}

Вместо значка # ставится знак перегружаемой операции.

Количество операндов у перегружаемой функции определяется тем, какая операция перегружается: одноместная или двухместная, а также наличием неявного аргумента у методов класса.

Point2D Point2D::operator-(Point2D p2)

{

Point2D temp;

temp.x=x-p2.x;

temp.y=this->y-p2.y;

return temp;

}

Когда перегружается бинарная операция, у функции будет только один параметр. Этот параметр получит объект, расположенный справа от знака операции. Объект слева вызывает функцию операции и передается неявно посредством использования указателя this. Важно понимать, что для написания функции операции имеется множество вариантов. Рассмотрим вторую реализацию

Point2D operator-(Point2D p2) const;

//Point2D.cpp

Point2D Point2D::operator-(Point2D p2) const

{

return Point2D(x-p2.x, y-p2.y);

}

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

//Point2D.h

Point2D operator-() const;

//Point2D.cpp

Point2D Point2D::operator-() const

{

return Point2D(-x, -y);

}

void main()

{

const Point2D p1(1,2);

Point2D p2(2,3), p3;

(p1-p2).print(); //неявный вызов операции минус

p1.operator-(p2).print(); //явный вызов

cout<<p1*p2<<”\n”;

(p1-20).print(); //будет использоваться операция преобразования типов

}

Надо обратить внимания, что имеется оператор с двумя переменными, выражение p1-20 будет корректно выполняться. В этом случае конструктор автоматически организует вызов конструктора с одним параметром и конструируется для него временный объект. И лишь после этого вызовет функцию-операцию. 2.0-p1 конструироваться не будет, потому что перегруженная операция является методом класса своего первого оператора, а для своего типа данных никакие перегрузки операций недопустимы.

Операции с С++ можно перегружать. Не перегружаются следующие операции:

1. .
2. .*
3. ::
4. ?:
5. sizeof

Можно перегружать + * / % ^ & |~!= <> += -= /= == && || ++ ->* -> [] () new delete

Большинство операций не может быть равно перегрузке. То есть те операции, которые выполняются раньше при перегрузке будут вести себя раньше. Изменить количество оперантов, которые берет на себя операция, невозможно. Перегружаемые унарные операции остаются унарными, а бинарные – бинарными. Нельзя создавать новые операции, можно перегружать только существующие. Нельзя изменить с помощью перегрузки операций смысла работы с переменами встроенного типа.

 

Дружественные функции

Те функции, которые не находятся в классе, но имеют доступ к его закрытой части.

Point2D p1, p2(1,2), p3;

(p1+p2).print();

(p1+2.0).print();

(2.0+p2).print(); //ошибка компиляции

В некотором случае хотелось бы более свободно использовать перегруженные операции для объекта Point2D. При этом из глобальных функций будет невозможен доступ к закрытой части класса, следовательно работа с самым классом. В С++ есть возможность разрешить доступ к закрытым частям класса глобальным функциям или член-функциям другого класса. Для разрешения доступа из этих функций ко всем данным класса надо перечислить эти функции в описании класса ключевым словом friend, создав, таким образом, дружественные классу функции.

//point2d.cpp

Point2D operator+(Point2D p1, Point2D p2)

{

return Point2D(p1.x+p2.x, p1.y+p2.y);}

//point2d.h

friend Point2D operator+(Point2D, Point2D);

1. Спецификатор доступа private, protected, public не имеет отношения к дружественности, так что это описание может помещаться в любом месте описания класса.
2. Рекомендуется помещать определения дружественности первыми в классе непосредственно после его заголовка и не предварять его каким-либо спецификатором доступа
3. Так как функции, объявленные как friend не являются член-функциями этого класса им не передается неявный указатель на объект класса. Значит, этот аргумент должен быть явно указан в списке аргументов функции.
4. При определении дружественной функции для доступа к полям всем аргументов, надо использовать составные имена.

 

ostream <<Point2D

ostreamf – возвращаемое значение

 

friend ostream& operator <<(ostream &, Point2D);

friend istream& operator >>(istream&, Point2D&);

 

//point2d.cpp

ostreamf operator<<(ostream& out, Poind2D p)

{

return out<<”Точка: ”

<<p.x<<” “

<<p.y;

}

 

istream operator >>(istream &in, Point2D&)

{

cout<<”Точка ”;

return in >>p.x>>p.y;

}

 

Point2D p2, const Point2D p1(1,2);

cin>>p2;

cout<<p1+p2<<”\n”

<<p1*p2<<”\n”;

cout<<p1+2<<2+p1<<”\n”<<p.y;

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

class B;

class C;

class A

{

int m1;

char m2;

friend void ff(A); //глобальная функция ff дружественная классу А

public

char fm(c);

char fm2(b,c);

};

 

class B

{

double mb2;

friend char A::fm2(B,C); //функция класса А, дружественная классу В

...

}

 

class C

{

char mc1;

friend class A; //все член-функции класса А дружественные классу С

...

}

При введении дружественных функций, надо быть осторожным, т.к. использование дружественных функций нарушает принцип сокрытия информации или принцип инкапсуляции. Как правило, дружественные функции используются для перегрузки операций и для создания класса операндов.