Константные объекты и константные функции-элементы

Пример объявления константного объекта:

const time noon(12,0,0); //полдень

Случайные попытки изменить константный объект отлавливаются во время компиляции и не вызывают ошибок во время выполнения.

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

class time {

public:

time(int=0, int=0, int=0);

void settime(int, int, int);

void seth(int);

void setm(int);

void sets(int);

int geth() const;

int getm() const;

int gets() const;

void printtime() const;

private:

int h, m, s;

};

Начальные значения константному объекту присваивает конструктор. Если же данные-элементы объявлены как const, например,

const int h;

то используется инициализатор элементов, чтобы обеспечить конструктор объекта начальными значениями данных-элементов:

time::time(int hr, int mr, int sr)

:h(hr) //инициализатор элемента h

{ m=mr; s=sr; }

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

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

(.), (->*), (.*), (?:), (::), (#), (##), (sizeof).

Перегрузка операций осуществляется с помощью функций специального вида (функций-операций)

тип operator операция(список параметров) {тело функции}

по правилам:

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

2. для стандартных типов переопределять операции нельзя;

3. функции-операции не могут иметь аргументов по умолчанию;

4. функции-операции наследуются (за исключением =);

5. функции-операции не могут определяться как static.

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

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

а) Префиксный инкремент (декремент)

1) Функция-операция – как функция-элемент:

class time{

--------------------

time& operator++() {++h; return *this;}

--------------------

};

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

2) Функция-операция – как дружественная функция:

class time{

friend time& operator++(time& t);

--------------------

};

Определение дружественной функции:

time& operator++(time& t) {++t.h; return t;}

3) Функция-операция – как просто функция. Она определена вне класса; и если объявлена – тоже вне класса.

time& operator++(time& t)

{ int k=t.geth();

k++;

t.seth(k);

return t;

}

//----------------------------------------------------------------------------------------------

Во всех трех случаях функция-операция используется одинаково:

void main(0

{ -------------

time t;

cout<<(++t).geth();

------------

}

//----------------------------------------------------------------------------------------------

б) Постфиксный инкремент (декремент)

Для отличия от функции-операции префиксного инкремента (декремента), функция-операция постфиксного инкремента (декремента) имеет параметр типа int:

class time {

----------------

time operator++(int) { h++; time t(*this); return t; }

--------------------------

};

Примечание. Локальный объект t создается как копия текущего объекта.

void main()

{ -----------

time t;

cout<<(t++).geth();

-------------

}