Qt – это не только элементы графического интерфейса. Этот фреймворк представляет собой взаимосвязанную систему. Родственность Qt-объектов осуществляется через наследование класса QObject. А связи между ними через сигнально-слотовую систему.В этой статье будут описаны основные классы и полезные особенности этой библиотеки.

QObject

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

• Прослеживание за потомками и родителями и возвращение указателей на них (Наследственная информация).
• Программная реализация таймера
• Динамические свойства
• Интернационализация приложения

QApplication

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

• Инициализирует приложение в соответствии с пользовательскими настройками.
• Выполняет обработку сообщений и передачу их соответствующим виджетам.
• Анализирует аргументы командной строки и соответствующим образом устанавливает свой внутреннее состояние.
• Определяет внешний вид приложения через установку стиля и изменение разрешенных цветов.
• Предоставляет ссылки на глобальный буфер обмена(clipboard()) и другие полезные объекты.
• Следит за открытыми окнами приложения и может выдать информацию о них.
• Управляет видом иконки курсора.
• И другие полезные функции.

Слоты и сигналы:

Для того чтобы объекты могли общаться, был введён механизм сигналов и слотов. С помощью этого объекты сообщают друг другу о произошедших событиях и отсылают нужные данные. Слот, как и функция-член, может быть публичной, приватной, защищённой или виртуальной. Он вызывается, если приходит подсоединённый к нему сигнал. Он в свою очередь генерируется, если в коде обработки события имеется вызов(макрос) emit signal().

Для себя можно представить определенную схему:

Событие ➞Генерация сигнала➞Передача параметров в слот.

Как выглядит в программе:

«Щелчок по кнопке» ➞ программная обработка ➞ signal(clicked()) ➞ slot(myslot()).

Основа для создания:

В классе, который должен будет иметь свои сигналы и слоты, нужно произвести наследование от QObject или другого класса библиотеки, наследующего его, и определить макрос Q_Object, с помощью этого объявления компилятор понимает, что необходимо сгенерировать из написанного qt-кода, который использует свои нововведения, в равнозначный шаблонный код стандартного C++. Начиная с Qt 5.0 появился новый способ соединения:

1)Ранняя версия:

QObject::connect(&Отправитель,SIGNAL(mysignal()),&Адресат,SLOT(myslot()));

Для создания связи необходимо прописать:

1. Отправителя и его сигнал.
2. Получателя и его слот.
3. А также тип соединения, который зависит от того используете вы соединение в потоке или нет. По умолчанию тип соединения определяется автоматически.

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

QObject::disconnect(&Отправитель,SIGNAL(mysignal()),&Адресат,SLOT(myslot()));

2)connect(&Отправитель,&Class_1::mysignal,&Адресат,&Class_2::myslot);

Достоинства:

1. Проверка существования сигналов и слота, типов, или если Q_OBJECT отсутствует(выдаёт ошибки).
2. Параметр может быть определением типа или с различными спецификаторами пространства имен.
3. Возможность автоматического приведения типов, если есть неявное преобразование (например, от QString до QVariant)
4. Возможно соединиться с любой функцией-членом класса(произведённого от QObject),а не только со слотами.

Недостатки:

1.    Более сложный синтаксис(Вы должны определить тип своего объекта)
2.    Очень сложный синтаксис в случаях перегрузок
3.    Параметры по умолчанию в слоте теперь не поддерживаются.

Нововведение: возможность соединения с простой функцией.

Благодаря новому синтаксису, появилась возможность соединения с функциями не являющимися слотами. Пример:connect(sender, &Sender::valueChanged, saveFunction);

Такая форма используется для разъединения:

Оба способа соединения разрешены для применения в программе. Так-как у них имеются различия нужно выбирать тот способ, который лучше подходит под ваши нужды.

Разберём на примере использование слотов и сигналов в программе.

Пример:

Добавьте в созданный на предыдущем уроке "sppstudio" новый подпроект lesson_2(Qt Widget).

Очистите его от посторонних файлов, оставив в нём main.cpp.Создайте в нем файлы myclass.h и myclass.cpp. Давайте придумаем функциональность для нашей программы. Пусть она при нажатии на кнопку создаёт окна и если число созданных окон превысит 5, то она закончит выполнение.

Перед вами реализация её класса:

//myclass.h
#ifndef MYCLASS
#define MYCLASS
#include <QLabel>
#include <QPushButton>
#include <QDialog>
#include <QHBoxLayout>
#include <QDebug>

//отображение числа нажатий
class MyClass:public QObject
{
Q_OBJECT
private:
    QPushButton * butt;
    QHBoxLayout * hbox;
    QWidget *window;
    static int counter;//счетчик объектов
public:
    MyClass();
    ~MyClass()
    {
        qDebug()<<"delete object MyClass";
        delete butt;
        delete hbox;
        delete window;
    }

private slots:
    void incCounter();//добавляет единицу к counter при вызове
    void newWindow();//создаёт новое окно
signals:
    s_transmitter();//сигнал передатчик
};
#endif // MYCLASS

В заголовочном файле прописываем слоты, сигнал и члены класса.

Обратите внимания на макросы:

Q_Object  — нужно прописывать в любом классе использующего свои слоты и сигналы.

private slots: и signals:  — здесь собственно они прописываются.

Определения методов у нас находятся в файле .cpp

Перейдём к его  детальному рассмотрению:

//myclass.cpp
#include "myclass.h"
#include <QString>
#include <QApplication>

MyClass::MyClass()
{
    butt = new QPushButton(" Создать ещё окно ");

    QString str;
    str = "Экземпляр №"+QString::number(counter);

    hbox = new QHBoxLayout;
    hbox->addWidget(butt);

    connect(butt,SIGNAL(clicked()),this,SLOT(incCounter()));
    connect(this,SIGNAL(s_transmitter()),this,SLOT(newWindow()));
    /*
    *Это старая версия соединения сигнала и слота
    *А ниже распологается новая:
    *connect(butt,&QPushButton::clicked,this,&MyClass::incCounter);
    *Вы можете выбрать эту версию
    *Для этой маленькой программы не будет большой разницы какой тип вы используете
    */

    window = new QWidget;
    window->setWindowTitle(str);
    window->setLayout(hbox);
    window->resize(230,45);
    window->move(200,80*counter);
    window->show();
}
void MyClass::incCounter()
{
    ++counter;
    if(counter>5)
    {
        QCoreApplication::quit();
        return;
    }
    emit s_transmitter();
}

void MyClass::newWindow()
{
    MyClass * m = new MyClass();
    m->setParent(this);
}
int MyClass::counter = 1;

Со строки 6 начинается описание конструктора MyClass. В нём создаётся окно с кнопкой и соединяются слоты с  сигналами. В 16-17 происходит соединение старого типа. За настройки вида приложения отвечают строки 27-31.

27: Установка названия окна

29: Размеры окна по x и y

30: Перемещает каждое новое окно вниз чтобы не нагромождать их на одном месте.

Последняя строка отвечает за появление окна на дисплее.

Функция incCounter отвечает за инкриминирование счётчика, вызов сигнала(строка 41) и выход из программы(36-40).

Функция newWindow создаёт новое окно и устанавливает ему родителя.Им становится объект у которого была нажата кнопка.

//main.cpp
#include <QApplication>
#include "myclass.h"
int main(int argc, char *argv[])
{
    QApplication a(argc, argv);
    MyClass myclass;
    a.exec();
    return 0;
}

И наконец main.cpp.

В нём прописывается автоматическая переменная-объект, которая удаляется при завершении программы.

Резюме:

Собственно в следующих статьях будет произведён упор не на описании базовых функций, а об использовании полезных особенностей библиотеки на практике. Здесь вы можете найти русский перевод документации по Qt 4.3 – 4.8. Описываются классы библиотеки, основные свойства и инструменты разработки.

Qt – это мощный инструментарий, имеющий множество способов для воплощения задумок программиста в жизнь. Давайте начнём его освоение с самой первой программы
Итак, у вас под рукой имеется среда разработки QtCreator с подключенным к ней компилятором(например MinGW). В среде разработки выбираем Другой проект-> Проект с поддиректориями.

Название: cppstudio. Здесь для удобства мы будем хранить все приложения взятые с сайта. Создадим здесь под проект QWidget с название lesson_1 и удаляем в нём файлы mainwindows.h, mainwindows.cpp, и форму.

Переписываем код программы печатающей на экран «Привет мир!» в main.cpp:

#include <QApplication>
#include <QHBoxLayout>
#include <QLabel>
#include <QPushButton>

int main(int argc, char *argv[])
{
    QApplication qapp(argc, argv);
    QHBoxLayout * hlayout = new QHBoxLayout;
    QLabel *label = new QLabel("Привет мир!");
    QPushButton *butt = new QPushButton("Exit");
    QWidget *mainWindow = new QWidget;
    QObject::connect(butt,SIGNAL(clicked()),&qapp,SLOT(quit()));
    hlayout->addWidget(label);
    hlayout->addWidget(butt);
    mainWindow->setLayout(hlayout);
    mainWindow->show();
    return qapp.exec();
}

Давайте разберём код программы:

В строчках 1-4 идёт подключение нужных заголовочных файлов.
В qt за графический интерфейс пользователя отвечает семейство классов <QWidget>. Так как нам понадобятся виджеты, то в первую очередь прописываем нужные библиотеки(QLabel, QPushButton).

#include <QApplication>
QApplication qapp(argc, argv);

Одноимённый класс, подключаемый через заголовочный файл QApplication нужен в любом Qt-проекте в единственном экземпляре. Он отвечает за отслеживание событий и сообщений в системе, изменения вида окон приложения и другие полезные функции.

QHBoxLayout * hlayout = new QHBoxLayout;
QLabel *label = new QLabel("Hello World");
QPushButton *butt = new QPushButton("Exit");
QWidget *mainWindow = new QWidget;

В этой части через динамическую память резервируется место под классы.

QObject::connect(butt,SIGNAL(clicked()),&qapp,SLOT(quit()));

Через метод класса QObjekt::connect(&Отправитель,SIGNAL(сигнал()),получатель,SLOT(слот())) реализуется механизм сигналов и слотов. В данном случае при нажатии кнопки приложения генерируется сигнал clicked(), который активирует слот quit() и приводит к закрытию приложения.

layout->addWidget(label);
layout->addWidget(butt);

Для расположения и компоновки виджетов “в сетке”, горизонтально или вертикально используются классы QHBoxLayout, QGridLayout, QHBoxLayout. Метод-член addWidget добавляет  их в менеджер компоновки.

mainWindow->setLayout(hlayout);
mainWindow->show();

Последние строки устанавливают окну класс компоновки с его виджетами и заставляют его стать видимым.

В итоге у вас должна получится программа:

Общая информация:

С начала использования программист получает взаимосвязанный фреймворк. Это даёт возможность при написании большей части программы использовать только встроенные классы и практически полностью отказаться от связи с определённой ОС. Такой подход реализует независимость и свободу разработчика.
(Отсутствует необходимость переписывать программу под несколько операционных систем. Алгоритм для Windows может, скомпилирован в том же виде под Linux) .

Основные инструменты и нововведения

Designer

С помощью этого средства можно с относительной лёгкостью создавать окна для вашего проекта. Полученный интерфейс сохраняется в файл с расширением .ui, который подключается к создаваемой программе с помощью специальных методов.

Сигналы и слоты

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

Подготовка к работе

Установка /IDE

Собственно для программирования с использованием вам нужно скачать её отсюда. Выберете вариант Community. Далее можно выбрать тип загрузки онлайн-инсталятор или оффлайн-инсталляторы.
Среда разработки Creator включена в стандартный бинарный пакет

Документация и помощь

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

Новые типы расширений, используемые в проектах Qt:

.pro

Файл с этим расширением хранит основные настройки программы: подключаемые модули, формы, файлы с исходным кодом и заголовочные файлы.

#-------------------------------------------------
#
# Project created by QtCreator 2001-07-08T12:04:54
#
#-------------------------------------------------

QT += core gui

greaterThan(QT_MAJOR_VERSION, 4): QT += widgets

TARGET = program_01

TEMPLATE = app

SOURCES += main.cpp\
mywindow.cpp

HEADERS += mywindow.h

FORMS   += mywindow.ui

Так в этом примере проект содержит:

• Модули: core, gui;
• Исходный код в main.cpp и mywindows.cpp;
• Формы дизайнера: mywindows.ui;
• Заголовочные файл: mywindows.h;
• Имя проекта:  program_01;

.ui

Это файл формы дизайнера. В неё можно, не выходя из среды разработки, добавлять новые виджеты (кнопки, метки, строки ввода). То есть это даёт возможность быстро создавать пользовательский интерфейс (окна приложений, диалогов, оповещений и т.д.)

Резюме

На сегодняшний день эта библиотека представляет собой, инструмент о существовании которого полезно знать, чтобы вести быструю разработку пользовательских приложений. Это мощное средство создания графических интерфейсов может помочь вам в уменьшении требований к адаптации программы под конечную платформу. Что конечно же даёт вам сконцентрироваться на задаче и алгоритмах её решения, а не на проблемах совместимости с операционной системой.

Вот примеры нескольких программ использующие Qt: Battle.net, Google Earth, Skype, медиапроигрыватель VLC, VirtualBox.

Пример:

#include <iostream>
using namespace std;

class FirstClass	// базовый класс
{
protected:			// спецификатор доступа к элементу value
	int value;
public:
	FirstClass() 
	{
		value = 0; 
	}

	FirstClass( int input )	
	{ 
		value = input; 
	}

	void show_value() 
	{
		cout << value << endl;
	}
};

class SecondClass : public FirstClass	// производный класс
{
public:
	SecondClass() : FirstClass ()	// конструктор класса SecondClass вызывает конструктор класса FirstClass
	{}

	SecondClass(int inputS) : FirstClass (inputS)	// inputS передается в конструктор с параметром класса FirstClass
	{}

	void ValueSqr () // возводит value в квадрат. Без спецификатора доступа protected эта функция не могла бы изменить значение value
	{
		value *= value;		
	}	
};

int main()
{
    setlocale(LC_ALL, "rus");

	FirstClass F_object(3);		// объект базового класса
	cout << "value F_object = ";
	F_object.show_value(); 

	SecondClass S_object(4);	// объект производного класса
	cout << "value S_object = ";
	S_object.show_value();  // вызов метода базового класса

	S_object.ValueSqr();		// возводим value в квадрат 
	cout << "квадрат value S_object = ";
	S_object.show_value();

	//F_object.ValueSqr();		// базовый класс не имеет доступа к методам производного класса

	cout << endl;
	return 0;
}

Разбирать пример будем по-порядку. Ранее мы работали только со спецификаторами доступа private и  public.  В строке 6 мы встретили новый для нас спецификатор доступа protected. Он отличается от private тем, что разрешает доступ к элементам базового класса из производных классов. Если бы элемент value находился в поле private, то доступ к нему был бы закрыт и мы бы не могли изменить его значение через объект класса SecondClass, используя функцию ValueSqr() , определённую в строках 34 — 37.

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

Если вы создаёте класс, который в дальнейшем планируете использовать, как базовый, то объявляйте в нём поле protected вместо private. Иначе объекты производного класса не смогут обращаться к элементам базового.

Ниже, в строках 8 — 22, определены методы базового класса. Конструктор без параметров FirstClass(), конструктор с параметром FirstClass( int input )  и метод void show_value(), который выводит значение value на экран.

Определение производного находится в строках 25 — 38. Синтаксис наследования такой — class   Имя_Производного_Класса    :    спецификатор доступа    Имя_Базового_Класса   {  } ; Двоеточие :  не путайте с двойным двоеточием :: (определение области действия).  Используя этот оператор мы показываем, наследником какого класса является производный класс.

Важной особенностью производного класса, является то, что хоть он и может использовать все методы и элементы полей protected и public базового класса, но он не может обратиться к конструктору с параметрами. Если конструкторы в производном классе не определены, при создании объекта сработает конструктор без аргументов базового класса. А если нам надо сразу при создании объекта производного класса внести данные, то для него необходимо определить свои конструкторы. В нашем примере показано, как же мы всё-таки можем использовать уже готовые конструкторы базового класса, чтобы не набирать код конструкторов снова — строки 28 — 32. Для этого при определении конструктора производного класса после его имени следует поставить оператор : и  имя конструктора базового класса, который необходимо вызвать, при создании объекта производного класса — SecondClass() : FirstClass (){}. Тело конструктора оставляем пустым т.к. всю работу проделает конструктор базового класса.  В случае конструктора с параметром, этот параметр мы передаем в конструктор с параметром базового класса SecondClass(int inputS) : FirstClass (inputS){} — строка  31.

В main-функции создаем объекты базового и производного классов — FirstClass F_object(3); и  SecondClass S_object(4); и отображаем их значения value на экран. Как видите в строке 50,  объект производного класса без проблем обращается к методу show_value() базового класса. Так, будто это его собственный метод. Ниже вызываем метод, который возводит значения value производного класса в квадрат. И выводим это изменённое значение на экран. А вот если мы захотим вызвать этот метод —  F_object.ValueSqr(); —  для объекта базового класса, компилятор нам этого не позволит сделать и выдаст ошибку. Это еще одна важная особенность — производный класс имеет доступ к базовому классу, а базовый класс, даже «не знает» о существовании производного и не может пользоваться его кодом.

 Результат работы программы:

В виде списка приведу  основную информацию о наследовании классов, которую важно знать:

• Наследование — это определение производного класса, который может обращаться ко всем элементам и методам базового класса за исключением тех, которые находятся в поле private;
• Производный класс еще называют потомком или подклассом, а базовый — родитель или надкласс;
• Синтаксис определения производного класса:    class   Имя_Производного_Класса    :    спецификатор доступа    Имя_Базового_Класса   { /*код*/ } ; 
• Производный класс имеет доступ ко всем элементам и методам базового класса, а базовый класс может использовать только свои собственные элементы и методы.
• В производном классе необходимо явно определять свои конструкторы, деструкторы и перегруженные операторы присваивания  из-за  того,  что  они  не  наследуются  от  базового  класса. Но  их  можно вызвать явным образом при определении конструктора, деструктора или перегрузки оператора присваивания производного класса, например таким образом (для конструктора): Конструктор_Производного_Класса (/*параметры*/)  :  Конструктор_Базового_Класса ( /*параметры*/) { } .
• Еще один важный момент при наследовании — перегруженные функции-методы  класса потомка. В данном примере мы его не рассматривали. Но чтобы вы знали, если в  классе родителе и в его классах потомках встречаются методы с одинаковым именем, то для объектов  класса потомка компилятор будет использовать методы именно класса потомка. Перегруженные методы класса потомка, могут вызывать методы класса родителя. В таком случае важно помнить, что необходимо правильно определить область действия с помощью оператора :: .Иначе компилятор воспримет это, как вызов функцией самой себя.  Наглядно, если бы мы перегрузили в классе SecondClass функцию show_value() — это  выглядело бы так:

void show_value() 
{
	if(value != 0) 
		FirstClass :: show_value();
}

Эта запись указывает компилятору  — если значение value не равно нулю — вызвать метод show_value() класса FirstClass. А он в свою очередь, отобразит это значение на экране.

Думаю для первого знакомства с наследованием классов этого достаточно. Это бесспорно классная возможность языка С++. Она помогает экономить массу времени на написание и отладку кода с нуля. Вместо этого мы можем использовать уже готовый и отлаженный код и подстраивать его под новые задачи, которые поставлены перед нами. При этом наша новая программа будет занимать намного меньше строк, что значительно улучшит её читабельность.

Поставим перед собой следующие задачи:

• создать класс, который будет содержать элементы:  int *numbers — указатель на массив целых чисел  и sizeOfArray — размер этого массива;
• перегрузить оператор [] так, чтобы мы могли из main-функции присваивать значение элементам массива класса.  Например, написав выражение Object[0] = 3, значение 3 запишется в ячейку с индексом 0 массива int *numbers. Теперь нам не придется определять и вызывать метод, который бы выполнял эту операцию (к примеру: Object.setNumber(0,3); где 0 – индекс массива а 3 – то что нужно записать);
• перегрузить оператор   ==  чтобы можно было сравнить массивы  int *numbers  двух разных объектов класса;
• перегрузить оператор  =  так, чтобы записав выражение Object = Object2 массив int *numbers объекта Object  стал идентичными массиву объекта  Object2 и по количеству ячеек массива и по значениям, которые хранят ячейки массива.

 Вот решение:

#include <iostream>
using namespace std;

class MyArray
{
	int *numbers;
	int sizeOfArray;
public:
	MyArray()		//конструктор без параметров
	{
		sizeOfArray = 0;	
		numbers = 0;
	}
//-----------------------------------------------
	MyArray(int size)		//конструктор с параметрами
	{
		sizeOfArray = size;	
		numbers = new int [sizeOfArray];
		for(int i = 0; i < sizeOfArray; i++)
		{
			numbers[i] = 0;
		}
	}
//-----------------------------------------------
	~MyArray()		//деструктор
	{
		delete [] numbers;
	}
//-----------------------------------------------
	void showData()			//вывод данных массива на экран
	{
		for(int i = 0; i < sizeOfArray; i++)
		{
			cout << numbers[i] << " | ";
		}
	cout << endl << endl;
	}
//-----------------------------------------------
	// на место вызова [] вернется по ссылке сам объект 
	int &operator[](int j) //перегрузка []		
	{
		return numbers[j];
	}
//-----------------------------------------------

	MyArray& operator=( MyArray &arrInt2 ) //перегрузка оператора присваивания
	{
		delete [] numbers;

		sizeOfArray = arrInt2.sizeOfArray;

		numbers = new int [sizeOfArray];
		for (int i = 0; i < sizeOfArray; i++)
		{
			numbers[i] = arrInt2.numbers[i];
		}

		return *this;
	}
//-----------------------------------------------
	friend bool operator ==( MyArray &arrInt, MyArray &arrInt2 ); //перегрузка ==
};

bool operator == ( MyArray &arrInt, MyArray &arrInt2 ) 
{
	if(arrInt.sizeOfArray != arrInt2.sizeOfArray) //сравниваем размеры массивов объектов
	{
		cout << "В массивах разное количество элементов\n";
		return 0;
	}
	else //проверяем равны ли данныев в ячейках массивов
	{		
		for (int i = 0; i < arrInt.sizeOfArray; i++)
		{
			if(arrInt.numbers[i] != arrInt2.numbers[i])
			{
				cout << "Значения массивов не равны\n";
				return 0;
			}				
		}	
	}
return 1; 
}

int main()
{
	setlocale(LC_ALL, "rus");

	MyArray ArrayInt(5);	//создаем объект класса и записываем в него данные
	ArrayInt[0] = 1; //перегруженный []
	ArrayInt[1] = 2;
	ArrayInt[2] = 3;
	ArrayInt[3] = 4;
	ArrayInt[4] = 5;
	cout << "Массив ArrayInt:  ";
	ArrayInt.showData();	//вывод данных массива на экран

	MyArray ArrayInt2(5); //создаем второй объект класса
	ArrayInt2[0] = 11; //перегруженный []
	ArrayInt2[1] = 22;
	ArrayInt2[2] = 33;
	ArrayInt2[3] = 44;
	ArrayInt2[4] = 55;
	cout << "Массив ArrayInt2: ";
	ArrayInt2.showData();	//вывод данных массива на экран

	if(ArrayInt == ArrayInt2){ //сравнение двух объектов класса (перегруженный ==)
		cout << "Массив ArrayInt равен массиву ArrayInt2\n";
	}
	else {
		ArrayInt = ArrayInt2;
	}
	cout << "Массив ArrayInt после копирования:  ";
	ArrayInt.showData();

	MyArray ArrayInt3(10); // третий объект класса с массивом из 10 элементов 
	cout << "Массив ArrayInt3: ";
	ArrayInt3.showData();
	ArrayInt3 = ArrayInt; // копируем массив из ArrayInt в ArrayInt3
	cout << "Массив ArrayInt3 после копирования: \n";
	ArrayInt3.showData();

	return 0;
}

И так — определяем класс MyArray .  В строках 9 — 28 определены конструкторы и деструктор.  Тот конструктор, который принимает параметр, будет сразу, при создании объекта класса, задавать размер sizeOfArray массива numbers. В строках 39-43 перегружаем оператор индексирования []. На место вызова [] вернется по ссылке сам объект и в ячейку его массива numbers  под номером j мы сможем записать целое число.    

Ниже в строках 46 — 59 перегружаем = (присваивание). Он будет копировать массив одного объекта класса MyArray в массив другого объекта класса. Чтобы это произошло, достаточно будет написать следующее выражение Object = Object2. При использовании перегруженного =, вызывается функция  MyArray& operator=( MyArray &arrInt2 ) определенная в классе.  Первый параметр (объект класса который прописан слева от знака = ) в нее передается неявным образом по указателю this, а тот, что в скобках – это тот объект который указан справа от =. Далее выполняется код тела этой функции – определение нового размера массива первого объекта и корректное копирование в него данных элементов массива второго объекта. Возвращает функция указатель на объект return *this; (указатель на самого себя, только уже с внесенными изменениями).

Перегрузка == (равенства) у нас определена в строках 64 — 83. А в теле класса прописан ее прототип, как дружественной функции класса. Так как оператор == используется для сравнения объектов, то функция его перегрузки  будет возвращать значение типа bool.  Она вернет 1, если массивы объектов равны  и по размеру и, по значениям в ячейках массивов. А если нет – вернет 0 и соответствующее сообщение о том,  что не совпадает.

Ну а в  main() мы просто применяем все перегруженные операторы так, как нам надо для работы.

Результат работы программы:

В этой статье речь пойдёт о буфере и о таймере отсчёта.

Для начала убедитесь, что Вы разбираетесь в выделении памяти с помощью функции alloc (malloc), free, с помощью операторов new, delete и понимаете функцию преобразованию itoa().

Рассмотрим листинг, представленный ниже:

LRESULT CALLBACK WindowProcess(HWND hWindow, UINT uMessage, 
			       WPARAM wParameter, LPARAM lParameter)
{
	HDC hDeviceContext;
	PAINTSTRUCT paintStruct;
	RECT rectPlace;
	HFONT hFont;

	static PTCHAR text;
	static int size = 0;

	switch (uMessage)
	{
	case WM_CREATE:
		text=(PTCHAR)GlobalAlloc(GPTR,50000*sizeof(TCHAR));
		break;
	case WM_PAINT: 
		hDeviceContext = BeginPaint(hWindow, &paintStruct);
		GetClientRect(hWindow, &rectPlace); 
		SetTextColor(hDeviceContext, NULL); 
		hFont=CreateFont(50,0,0,0,0,0,0,0,
				 DEFAULT_CHARSET,
				 0,0,0,VARIABLE_PITCH,
				 "Arial Bold");
		SelectObject(hDeviceContext,hFont);
		if(wParameter != VK_RETURN)
			DrawText(hDeviceContext,
				 (LPCSTR)text,
				 size, &rectPlace,
				 DT_SINGLELINE|DT_CENTER|DT_VCENTER);
		EndPaint(hWindow, &paintStruct);
		break;
	case WM_CHAR:
		switch(wParameter)
		{
		case VK_RETURN:
			size=0;
			break;
		default:
			text[size]=(char)wParameter;
			size++;
			break;
		}
		InvalidateRect(hWindow, NULL, TRUE);
                break;
	case WM_DESTROY:
		PostQuitMessage(NULL);
		GlobalFree((HGLOBAL)text);
		break;
	default:
		return DefWindowProc(hWindow, uMessage, wParameter, lParameter);
	}
	return NULL;
}

Результат после ввода CppStudio.com будет таким:

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

Наверное, Вы заметили, что в программе в предыдущем уроке для считывания нажатой клавиши мы использовали message WM_KEYDOWN, а здесь что-то новое — WM_CHAR.

Отличительная особенность в том, что WM_KEYDOWNнужен для обработки специальных клавиш типа shift, ctrl и т.п., а WM_CHAR– отвечает за обработку символов. Обычно они работают вместе для комбинаций клавиш и вызывают друг друга. В этом Вы убедитесь, когда мы будем разбирать работу текстового редактора.

По умолчанию в MVS используется Юникод. Его отключение производится следующим образом: заходим в свойства проекта

и отключаем Юникод, нажав «Использовать многобайтовую кодировку».

После того, как Вы это сделаете, перед строками не нужно будет писать L, и представленный код не будет иметь ошибок. По этой причине в программе прошлого урока было не правильное отображение некоторых символов.

Теперь второе отличие: мы можем вводить текст (примерно до 50 кБ), который сохранится в буфере.

Конструкция создания, использования, удаления буфера выглядит так:

static PTCHAR text;
text=(PTCHAR)GlobalAlloc(GPTR,50000*sizeof(TCHAR));
if()
{
   //....
   // заполняем буфер информацией, используем её, где нам нужно
   //.....
   GlobalFree((HGLOBAL)text);
}

Она аналогична alloc() и free() и её смысл абсолютно такой же.

PTCHAR — указатель на тип TCHAR.

GPTR — режим выделения памяти (в данном случае фиксированное)
HGLOBAL — тип возвращаемого значения функции GlobalAlloc()

Третье достоинство нашей программы — возможность стирать текст (строки 36-38).

В случае нажатия клавиши ENTER – мы делаем окно не действительным с помощью функции InvalidateRect() (строка 44), тем самым вызываем сообщение WM_PAINT. В нём прописано, что если параметр wParameter был равен VK_RETURN (то есть ENTER), то мы перерисовываем окно и не вызываем функцию DrawText().

И, как и обещалось ранее, добавим в функцию таймер и некоторые другие особенности.

static int sec = 0; 
TCHAR workTime[10];
//...
switch (wParameter)
{
case WM_CREATE:
    SetTimer(hWindow, 1, 1000, NULL);
    //...
    SetForegroundWindow(hWindow);
    break;
case WM_CHAR:
    //...
    case VK_BACK: 
       if(size!=0) 
          size--; 
       break;
case WM_TIMER:
    sec++;
    break;
case WM_DESTROY:
    KillTimer(hWindow, 1);
    _itoa(sec, workTime, 10); MessageBox(NULL, (LPCSTR)workTime, "Время работы программы (сек.):", MB_ICONASTERISK|MB_OK);
    //...
    break;
}

Добавьте в соответствующие места программы выше представленный код.

Функция SetTimer() создаёт таймер. Первый параметр — дескриптор окна, третий — интервал срабатывания WM_TIMER в миллисекундах, второй — количество вызовов WM_TIMER в заданный интервал времени. Четвёртый параметр — нам не нужен.

В сообщении WM_TIMER мы увеличиваем sec на единицу.

Функция KillTimer() — удаляет таймер. Параметры те же, что и в SetTimer().

Чтобы отобразить время работы программы, в WM_DESTROYмы преобразовываем int в TCHAR массив при помощи функции _itoa, выводим строку на экран, удаляем таймер и освобождаем память, выделенную под буфер.

Функция SetForegroundWindow(HWND) – делает окно активным. Например, если Вы находитесь на сайте CppStudio.com и при этом идёт компиляция данной программы, это окно появится поверх браузера с фокусом для ввода.

Для возможности удаления одного или нескольких символов добавлен обработчик VK_BACK– нажатие клавиши backspace. Если size не равен нулю (то есть не был нажат ENTER), мы уменьшаем его на единицу и последний элемент при обновлении окна не отображается.

В результате, при закрытии окна, мы получим такое сообщение:

До встречи в следующем уроке!

char *itoa( int value, char * string, int radix );

Заголовочный файл

Описание

Функция itoa преобразует целое число value в строку string в формате radix. К цифрам числа value подбираются ANSI символы типа char и записываются в строку string.

Функция имеет неудобство, заключающееся в том, что при числе, имеющем количество цифр, большее, чем размер строки, функция выдаст ошибку. Поэтому нужно устанавливать размер с запасом.

Также данная функция поддерживается только Visual Studio и в других IDE не имеет описания.

Параметры:

• value — преобразуемое число
• string — строка, в которую преобразуется число
• radix — основание степени счисления

Возвращаемое значение

Функция itoa всегда возвращает указатель на string. Чтобы отследить неправильное преобразование, используйте функцию _itoa_s, описание которой:

char *_itoa_s( int value, char * string, int size, int radix );

где size — размер строки string. Данная функция возвращает ноль, если преобразование проходит успешно.

Пример: исходный код программы

Код MVS С++

#include "stdafx.h"
#include <iostream>
#include <cstdlib>

int main(int argc, char ** argv)
{
        int value;
        char string[6] = "";
        setlocale(LC_ALL, "Russian");
        std::cout << "Введите число: ";
        std::cin >> value;
        itoa(value, string, 10);
        std::cout << "Введённое число при radix = 10: " << string << std::endl;
        std::cout << "Элементы строки: " << std::endl;
        for( int i = 0; i < 6; i++ )
             std::cout << string[i];
        std::cout << "." << endl;
        itoa(value, string, 16);
        std::cout << "Введённое число при radix = 16: " << string << std::endl;
        system("pause");
        return 0;
}

Пример работы программы

map<char,int> MapFirst,MapSecond,temp;

temp=MapFirst;
MapFirst=MapSecond;
MapSecond=temp;

Но в С++ предусмотрена для этого специальная функция map::swap(), которая позволяет менять содержимое контейнеров map и multimap местами, сейчас покажу как.

#include <iostream>
#include <map>

using namespace std;
int main ()
{
  map<char,int> MapFirst;
  map<char,int> MapSecond;

  MapFirst['a']=1;
  MapFirst['b']=2;

  MapSecond['z']=23;
  MapSecond['y']=22;

  cout << "MapFirst keeps before swap:  MapSecond keeps before swap:" << endl;
  auto itMapFirst=MapFirst.begin();
  auto itMapSecond=MapSecond.begin();
  for(itMapFirst,itMapSecond; itMapFirst != MapFirst.end(); ++itMapFirst,++itMapSecond)
  {
      cout << itMapFirst->first << " : " << itMapFirst->second << "\t\t\t\t\t"
      << itMapSecond->first << " : " << itMapSecond->second <<endl;
  }

  swap(MapFirst,MapSecond);///обмен 

  cout << "MapFirst keeps after swap:    MapSecond keeps after swap:" << endl;
  itMapFirst=MapFirst.begin();
  itMapSecond=MapSecond.begin();
  for(itMapFirst,itMapSecond; itMapFirst != MapFirst.end(); ++itMapFirst,++itMapSecond)
  {
      cout << itMapFirst->first << " : " << itMapFirst->second << "\t\t\t\t\t"
      << itMapSecond->first << " : " << itMapSecond->second <<endl;
  }

  MapFirst.swap(MapSecond);///обмен

  cout << "MapFirst keeps after anoter swap:    MapSecond keeps after anoter swap:" << endl;
  itMapFirst=MapFirst.begin();
  itMapSecond=MapSecond.begin();
  for(itMapFirst,itMapSecond; itMapFirst != MapFirst.end(); ++itMapFirst,++itMapSecond)
  {
      cout << itMapFirst->first << " : " << itMapFirst->second << "\t\t\t\t\t"
      << itMapSecond->first << " : " << itMapSecond->second <<endl;
  }

  return 0;
}

Вывод программы:

В строках 10, 11 мы заполняем контейнер MapFirst, в строках 13,14 контейнер MapSecond.

Обратите внимание на еще один вариант заполнения контейнера map. В квадратных скобках мы указываем наш ключ, а после знака равенства — значение.

В строках 19-23, выводим на экран содержимое наших контейнеров. В строке 25 происходит смена элементов двух контейнеров. Теперь контейнер MapFirst содержит то, что содержал контейнер MapSecond, а MapSecond содержит значения контейнера MapFirst.

Важно: функция map::swap() работает только в случае, если контейнеры относятся к одному типу т. е., если вы напишите, что-то вроде этого:

map<char,int> MapFirst;
map<char,float> MapSecond;

компилятор выдаст ошибку. Будьте внимательны, не допускайте подобного.

В строках 30-34 осуществляется вывод на экран. Альтернативный вариант функции map::swap() показан в строке 36 и вывод в строках 41-45 показывающий, что функция отработала верно. Для контейнера multimap все работает так же, как и для контейнера map.

#include <iostream>
#include <map>

using namespace std;
int main ()
{
  multimap<float,string> myMultimapExample;
  map<string,float> myMapExample;

  /// первый вариант
  myMapExample.insert ( pair<string,float>("Desk",0.01) );
  myMapExample.insert ( pair<string,float>("Table",0.02) );
  myMultimapExample.insert ( pair<float,string>(0.01,"Desk") );
  myMultimapExample.insert ( pair<float,string>(0.01,"Table") );

  /// второй вариант
  multimap<float,string>::iterator itMultimapExample = myMultimapExample.begin();///итератор указывает на начало multimap
  map<string,float>::iterator itMapExample = myMapExample.begin();
  myMapExample.insert ( itMapExample, pair<string,float>("Pencil",0.03) );
  myMultimapExample.insert ( itMultimapExample, pair<float,string>(0.03,"Pencil") );

  /// третий вариант
  map<string,float> myMapExampleDifferent;
  multimap<float,string> myMultimapExampleDifferent;
  myMapExampleDifferent.insert( myMapExample.begin(),myMapExample.find("Table") );
  myMultimapExampleDifferent.insert( myMultimapExample.begin(),myMultimapExample.find(0.03) );

  /// вывод на экран map и multimap:
  cout << "myMapExample: \t\t myMultimapExample:\n";
  for ( itMapExample = myMapExample.begin(),itMultimapExample = myMultimapExample.begin(); itMapExample != myMapExample.end(); ++itMapExample,++itMultimapExample)
  {
      cout << itMapExample->first << " : " << itMapExample->second << "\t\t   " << itMultimapExample->first << " : " << itMultimapExample->second << endl;
  }

  auto itMapExampleDif = myMapExampleDifferent.begin();
  auto itMultimapExampleDif = myMultimapExampleDifferent.begin();
  cout << "\nmyMapExampleDifferent: \t myMultimapExampleDifferent:\n";
  for ( itMapExampleDif,itMultimapExampleDif; itMapExampleDif != myMapExampleDifferent.end(); ++itMapExampleDif,++itMultimapExampleDif)
  {
      cout << itMapExampleDif->first << " : " << itMapExampleDif->second << "\t\t    " << itMultimapExampleDif->first << " : " << itMultimapExampleDif->second << '\n';
  }

  return 0;
}

Работа программы:

Если Вы используете MVS 2013 или MVS 2012, то не исключено возникновение вот такой ошибки:

Error C2679: бинарный «<<«: не найден оператор, принимающий правый операнд типа «const std::string» (или приемлемое преобразование отсутствует)

В программе показано три варианта заполнения контейнера multimap и map.

• Вариант №1 — или самый распространенный вариант. В строке 11 и 12 с помощью функции map:: insert(), мы добавляем элементы в map. Функция принимает два аргумента, первый аргумент ключ, у нас это тип string, второй это значение, у нас это тип float. Строки 13 и 14 идентичны строками 11 и 12, но там элементы добавляются в multimap.
• Вариант №2 — с использованием итератора. В строке 17 создаем итераторitMultimapExample, в строке 18, итератор itMapExample. Функцииmap::insert(), в строке 19 мы  передаем два аргумента (первым аргументом выступает наш итератор itMapExample, а вторым, пара  ключ, значение). Строка 20 равносильна строке 19,  только там функция map::insert(), применяется к контейнеру multimap. Может возникнуть вопрос, чем первый вариант отличается от второго? Ответ, тем, что нашим итератором мы рекомендуем позицию, с которой следует начинать поиск позиции элемента, который мы хотим вставить.
• Вариант №3 — с использованием функции map::find(). В строке 23, 24 объявляем еще один  контейнер map и multimap. Строку 25 можно прочитать так: заполняй контейнер myMapExampleDifferent,  начиная с начала myMapExample, пока в контейнере myMapExample не встретишь ключ Table. Этот ключ не  будет вставлен в myMapExample. Строка 26 выполняет предыдущее действие, но применительно к  multimap контейнеру. Вывод на экран myMapExample и myMultimapExample осуществляется в строках 30-33, а вывод myMapExampleDifferent и myMultimapExampleDifferent строках 38-41 .

Multimap кроме функции map::insert(), поддерживает еще функцию map::emplace(), рассмотрим  пример:

#include <iostream>
#include <map>

using namespace std;
int main ()
{
  multimap<char,float> mymultimap;
  map<char,float> mymap;

  ///заполняем multimap
  mymultimap.insert( pair<char,float>('a',0.1) );
  mymultimap.insert( pair<char,float>('b',0.2) );
  mymultimap.insert( pair<char,float>('d',0.4) );
  mymultimap.insert( pair<char,float>('e',0.5) );

  ///заполняем map
  mymap.insert( pair<char,float>('f',5.3) );
  mymap.insert( pair<char,float>('g',4.32) );
  mymap.insert( pair<char,float>('i',23.41) );
  mymap.insert( pair<char,float>('r',6.5) );

  ///вставляем элементы в multimap
  mymultimap.emplace('c',0.3);
  mymultimap.emplace('b',9.9);
  cout << "mymultimap have:" << endl;
  for (auto it = mymultimap.begin(); it != mymultimap.end(); ++it)
  {
      cout << it->first << " : " << it->second << endl;
  }

  auto lowerMap=mymap.lower_bound('g');/// нижняя граница map
  auto upperMap=mymap.upper_bound('i');///верхняя граница map
  auto lowerMultimap=mymultimap.lower_bound('b');/// нижняя граница multimap
  auto upperMultimap=mymultimap.upper_bound('d');///верхняя граница multimap

  mymultimap.erase(lowerMultimap,upperMultimap);
  mymap.erase(lowerMap,upperMap);
  auto itMultimap = mymultimap.begin();
  auto itMap = mymap.begin();
  cout << "\nmymultimap have: \t mymap have:" << endl;
  for (itMultimap,itMap; itMultimap != mymultimap.end(); ++itMultimap,++itMap)
  {
      cout << itMultimap->first << " : " << itMultimap->second << "\t\t  " << itMap->first  << " : " << itMap->second << endl;
  }
  return 0;
}

Работа программы:

В строках 11-14 происходит заполнение контейнера multimap, в строках 17-20 происходит заполнение контейнера map. В строке 23 встречается функция  map::emplace(), которая равносильна функции map::insert, но ей не нужно, явно, каждый раз,  указывать тип переменной. В строках 26-29 осуществляет вывод на экран контейнера multimap.  Контейнер map не поддерживает функцию map::emplace(). В строке 31 мы встречаем функцию map::lower_bound(). Эта функция принимает только один аргумент и возвращает первую позицию в которую может быть вставлен этот элемент. С помощью функции  map::lower_bound(), создаем итератор, указывающий на ключ g в контейнере map. В 32 строке мы встречаем функцию map::upper_bound(), она возвращает последнюю позицию , в которую может быть вставлен элемент. В строке 32 создаем еще один итератор, но уже с помощью функции map::upper_bound() и указывающий на ключ i. В строках 33, 34, выполняется тоже, но с контейнером multimap. Данные итераторы  выступают в роли «границ», где  при помощи map::erase() в строке 38, 39, мы очищаем оба  контейнера (границы контейнеров, тоже стираются). Что осталось в контейнерах, показано в  строках 43-46, где осуществляется вывод на экран.

Конструктор копирования нужен нам для того, чтобы создавать «реальные» копии объектов класса, а не побитовую копию объекта. Иногда это принципиально важно. Такую «реальную» копию объекта надо создавать в нескольких случаях:

• когда мы передаем объект в какую-либо функцию в виде параметра;
• когда какая-либо функция должна вернуть объект класса в результате своей работы;
• когда мы в главной функции один объект класса инициализируем другим объектом класса.

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

Чтобы избежать этих проблем и ошибок существует конструктор копирования. Его работа заключается в том, чтобы создать реальную копию объекта со своей личной выделенной динамической памятью. Синтаксис конструктора копирования следующий:

имяКласса (const имяКласса & object)
{
    //код конструктора копирования
}

Рассмотрим простой пример. В нем создадим класс, который будет содержать обычный конструктор, конструктор копирования и деструктор. В этом примере будут описаны все три случая для которых надо применять конструктор копирования.  Для того, чтобы пример не был слишком большим, мы не будем заставлять конструкторы выделять память, а деструктор освобождать память. Пропишем в них только вывод определенного сообщения на экран. Таким образом, можно будет посмотреть, сколько раз сработают конструкторы и деструктор. Как вы понимаете, если бы деструктор освобождал память, то количество его вызовов не должно превышать количество вызовов конструкторов.

Пример:

#include <iostream>
using namespace std;

class SomeClass
{	
	int *ptr; // указатель на какой-либо участок памяти
public:	

	SomeClass() //  конструктор
	{
		cout << "\nОбычный конструктор\n";
	}
	SomeClass(const SomeClass &obj)
	{		
		cout << "\nКонструктор копирования\n";
	}
	~SomeClass()	
	{
		cout << "\nДестркуктор\n";
	}
};
	void funcShow(SomeClass object) 
	{
		cout << "\nФункция принимает объект, как параметр\n";
	}

	SomeClass funcReturnObject()
	{	
		SomeClass object;		
		cout <<	"\nФункция возвращает объект\n";
		return object;
	}

int main()
{
	setlocale(LC_ALL,"rus");

	cout << "1 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n";
	SomeClass obj1; // создаем объект класса

	cout << "2 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n";
	funcShow(obj1); // передаем объект в функцию

	cout << "3 - 4 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n";
	funcReturnObject(); // эта функция возвращает объект

	cout << "5 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n";
	SomeClass obj2 = obj1;	// инициализация объекта при создании

}

В строках 4 — 21 определен класс. Обычный конструктор, строки 9 — 12, будет автоматически вызваться при создании новых объектов класса. А конструктор копирования, строки 13 — 16, будет автоматически вызваться при создании копии объекта. Деструктор, строки 17 — 20, вызывается всякий раз когда удаляется либо объект, либо его копия. Ниже определены две функции funcShow() и funcReturnObject(). Первая принимает объект в виде параметра, вторая при вызове во-первых создает новый объект (тут сработает обычный конструктор), а во-вторых возвращает объект (тут сработает конструктор копирования т.к. при возврате объекта из функции создается его временная копия).

Вот какую картинку мы увидим при запуске программы:

Пойдем по порядку. В первом блоке сработал обычный конструктор — это произошло при создании объекта класса obj1. Второй блок отображает работу функции funcShow(). Так как при передаче объекта в функцию создается его копия и сработал конструктор копирования. А при завершении работы функции эта копия уничтожается и срабатывает деструктор. Блок 3 — 4 показывает, что при создании нового объекта в функции funcReturnObject() сработал обычный конструктор, а при возврате объекта — конструктор копирования. Деструктор, как положено отработал дважды — для оригинала объекта и для копии. И наконец в пятом блоке срабатывает конструктор копирования при инициализации нового объекта класса. Затем дважды деструктор  — один уничтожает копию объекта пятого блока, второй уничтожает объект из первого блока. Ну как-то так. В итоге количество вызовов деструктора совпадает с вызовами конструкторов.

А теперь попробуйте закомментировать конструктор копирования в определении класса и запустите программу.  Вы увидите, что конструктор сработает только дважды, а деструктор, рад стараться, отработает пять раз. И если бы он освобождал память — это неизбежно  привело бы к ошибке программы.