Разделы презентаций


ООП Перегруженные операции. Объекты-исключения презентация, доклад

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

Слайды и текст этой презентации

Слайд 1Основы ООП
Перегруженные операции. Объекты-исключения

Основы ООППерегруженные операции. Объекты-исключения

Слайд 2Перегруженные операции
Перегруженные операции (формализм)
С++ позволяет переопределить большинство операций языка так,

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

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




Последние четыре операции означают: индексацию, вызов функции, размещение в динамической памяти и освобождение памяти.
Для дальнейшего изложения, обозначим @ - некоторую перегружаемую операцию языка С++. Пусть x и y – объекты некоторых классов С++.
Перегрузка унарных операций.
@x – унарная операция над объектом x в префиксной форме интерпретируется как вызов функции-члена
x.operator@( ) без аргументов
или вызов friend-функции с именем
operator@( x ) с одним аргументом.
x@ – унарная операция над объектом x в постфиксной форме интерпретируется как вызов функции-члена
x.operator@( int ) , где аргумент типа int - фиктивный
или вызов friend-функции с именем
operator@( x, int) , где аргумент типа int – фиктивный.
.

+ - * / % ^ & | ~ ! = < > += -= *= /= %= ^= &= |=
<< >> >>= <<= == != <= >= && || ++ -- ->* , -> [] () new delete

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

Слайд 3Перегруженные операции
Перегрузка бинарных операций.
x @ y – бинарная операция с

объектами x и y интерпретируется как вызов функции-члена
x.operator@( y )

с одним аргументом
или вызов friend-функции с именем
operator@( x , y ) с двумя аргументами.
Замечания к перегруженным операциям.
При перегрузке операций, полностью сохраняется синтаксис языка С++, в том числе приоритет и порядок выполнения операций.
Можно перегрузить операции new и delete и начать самостоятельно управлять процессами выделения и освобождения динамической памяти.
Можно перегрузить операцию индексации []. Индексы могут иметь любой тип (например, цвет, текст, др.). Это есть ассоциативные массивы.
Итераторы в контейнерах можно заменить «умными» перегруженными операциями «++» и «--», которые при обходе не позволяют выйти за пределы контейнера.
Можно переопределить операцию косвенной адресации объекта «->» для работы с «умными» указателями, которые при каждом обращении к объекту будут выполнять любую заданную вами работу.
Можно перегрузить операцию вызова функции, тогда запись вида <объект> ( <список-аргументов> ) будет рассматриваться как бинарная операция operator()(…).
Можно перегрузить операцию преобразования типа (собственный кастинг).
Перегруженные операцииПерегрузка бинарных операций.x @ y – бинарная операция с объектами x и y интерпретируется как вызов

Слайд 4Перегруженные операции
Перегруженные операции (пример)
Пример. Перегруженные операции для строк.


#pragma warning( disable

: 4996 4267 ) // выключим некоторые предупреждения
#include // понадобится

для сцепления строк
#include // задействуем потоковый ввод/вывод
using namespace std; // пространство имен для потокового в/в
class str { // опишем класс «строки»
char* s; // указатель на символы
int n; // емкость буфера для хранения строки
public:
str() { n=1; s=NULL; } // 0-конструктор (по умолчанию)
str(const str&); // конструктор копирования
str(const char*); // конструктор общего вида
~str() { if(s) delete s; } // деструктор
str& operator~(); // операция инверсии строки
str& operator=(char*); // операция присваивания
str& operator=(str&); // операция присваивания
friend str& operator+(str&, str&); // операция сложения
friend str& operator+(str&, char*); // операция сложения
friend str& operator+(char*, str&); // операция сложения
friend istream& operator>>(istream&, str&); // операция ввода
friend ostream& operator<<(ostream&, str&); // операция вывода
};
Перегруженные операцииПерегруженные операции (пример)Пример. Перегруженные операции для строк.#pragma warning( disable : 4996 4267 ) 	// выключим некоторые

Слайд 5Перегруженные операции
Конструкторы и инверсия строк

// инверсия строки
str& str::operator~() {
if(n>2) { //

имеет смысл для строк длиной больше 1 символа
char temp, *beg=s,

*end=s+n-2; // рабочие указатели
while(beg temp=*beg; *beg++=*end; *end--=temp; }
}
return *this; // результат работы – сам объект
}

// конструктор общего вида
str::str(const char *text) {
s = new char[n=strlen(text)+1]; // получим память
strcpy(s, text); // небезопасная функция!
}

// конструктор копирования
str::str(const str &x) {
s = new char[n=x.n]; // получим память
strcpy(s, x.s); // небезопасная функция!
}

Перегруженные операцииКонструкторы и инверсия строк// инверсия строкиstr& str::operator~() {	if(n>2) {	// имеет смысл для строк длиной больше 1

Слайд 6Перегруженные операции
Операторы присваивания

// оператор присваивания char*
str& str::operator=(char *text) {
if(s) delete[]

s; // освободим ранее использованную память
s = new char[n=strlen(text)+1]; // получим память
strcpy(s,

text); // небезопасная функция!
return *this; // результат работы – сам объект
}

// оператор присваивания str
str& str::operator=(str &x) {
if(this != &x) { // не присваиваем ли объект самому себе?
if(s) delete[] s; // освободим ранее использованную память
s = new char[n=x.n]; // получим память
strcpy(s, x.s); // небезопасная функция!
}
return *this; // результат работы – сам объект
}

Перегруженные операцииОператоры присваивания// оператор присваивания char*str& str::operator=(char *text) {	if(s) delete[] s;	// освободим ранее использованную память	s = new

Слайд 7Перегруженные операции

Операторы сложения

// дружественная функция: сложение двух объектов str
str& operator+(str

&x1, str &x2) {
str *sum = new str; // новый объект

– в нем будет сумма строк
sum->s = new char[ sum->n = x1.n + x2.n - 1]; // получим память
strcpy(sum->s, x1.s); // строка из первого объекта
strcat(sum->s, x2.s); // цепляем строку из второго объекта
return *sum; // результат – сцепленные строки
}

// дружественная функция: сложение объекта str + char*
str& operator+(str &x, char *text) {
str *sum = new str; // новый объект – в нем будет сумма строк
sum->s = new char[ sum->n = x.n + strlen(text) ]; // получим память
strcpy(sum->s, x.s); // строка из первого объекта
strcat(sum->s, text); // цепляем строку из второго объекта
return *sum; // результат – сцепленные строки
}

Перегруженные операцииОператоры сложения// дружественная функция: сложение двух объектов strstr& operator+(str &x1, str &x2) {	str *sum = new

Слайд 8Перегруженные операции
Сложение, ввод и вывод строк
// дружественная функция: сложение char*

и объекта str
str& operator+(char *text, str &x) {
str *sum =

new str; // новый объект – в нем будет сумма строк
sum->s = new char[ sum->n = strlen(text) + x.n ]; // получим память
strcpy(sum->s, text); // строка из первого объекта
strcat(sum->s, x.s); // цепляем строку из второго объекта
return *sum; // результат – сцепленные строки
}

// дружественная функция: потоковый ввод объекта str
istream& operator>>(istream &z, str &x) {
char buf[BUFSIZ]; // рабочий буфер для ввода
z.get(buf,BUFSIZ,'\n'); // используем метод get() объекта z
x=buf; // операция присваивания для класса str уже определена
return z; // возвращаем объект класса istream
}

// дружественная функция: потоковый вывод объекта str
ostream& operator<<(ostream &z, str &x) {
return z<}

Перегруженные операцииСложение, ввод и вывод строк// дружественная функция: сложение char* и объекта strstr& operator+(char *text, str &x)

Слайд 9Перегруженные операции
Тестирование класса str

// посмотрим, как работает класс str
void main(void)

{
str a, b="xxx", c; // обзаведемся тремя объектами
cin>>a; // потоковый ввод
c=a+b; //

сложение объектов
cout<<(a+" "+b+" "+c)< cout<<~a<}

Слайд 10Объекты-исключения
Объекты-исключения
В качестве введения в тему рассмотрим два фрагмента кода.
Фрагмент 1.






При

ошибке открытия файла следует проанализировать причины неудачи и предпринять некоторые

разумные действия для исправления ситуации.
Фрагмент 2.







Объект-потомок класса X не был создан, но конструктор объекта-предка класса Y уже отработал и мог получить (заблокировать) какие-то системные ресурсы.
Вопрос: какова дальнейшая судьба этих ресурсов, будут ли они освобождены?

File* f1() { // f1 – функция, которая пытается открыть некий файл
File *fp; // возможна нештатная ситуация – ошибка открытия файла
if ( ( fp = fopen ( …, … ) ) == NULL ) // возникла ошибка открытия файла
{ cerr << “file open err”; return NULL; } // сообщение и аварийный выход
return fp; } // успех, нормальный выход

int f2() { // f2 – функция, которая пытается создать объект-потомок
class X : public Y { … }; // возможна нештатная ситуация –
X *p = new X; // объект не будет создан из-за нехватки памяти
if ( p == NULL ) // объект не создан, но конструктор предка уже отработал
{ cerr << “object create err”; return -1; } // сообщение и аварийный выход
return 0; } // успех, нормальный выход

Объекты-исключенияОбъекты-исключенияВ качестве введения в тему рассмотрим два фрагмента кода.Фрагмент 1.При ошибке открытия файла следует проанализировать причины неудачи

Обратная связь

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

Email: Нажмите что бы посмотреть 

Что такое TheSlide.ru?

Это сайт презентации, докладов, проектов в PowerPoint. Здесь удобно  хранить и делиться своими презентациями с другими пользователями.


Для правообладателей

Яндекс.Метрика