Конструктор перемещения C++

Konstruktor Peremesenia C



Программирование на C++ — лучший язык, поскольку он предоставляет нам широкий спектр функций, конструкторов, заголовочных файлов, классов и многого другого, что делает кодирование более интересным и простым. Одним из конструкторов в программировании на C++ является конструктор перемещения. Конструктор «перемещения» — это уникальный тип конструктора, который позволяет эффективно и с учетом ресурсов передавать владение динамически выделяемой памятью или другими ресурсами от одного объекта к другому.

В программировании на C++ были введены конструкторы перемещения для уменьшения дублирования и повышения эффективности. Он играет решающую роль в повышении производительности за счет минимизации операций копирования. В этом руководстве подробно рассматривается конструктор «перемещения» в программировании на C++.







Пример 1:

Чтобы начать код, мы включаем заголовочные файлы «iostream» и «string», которые обеспечат идеальную работу нашего кода, поскольку в этих заголовочных файлах объявлено множество функций. Когда нам нужно использовать оператор «cout», используется заголовочный файл «iostream», поскольку эта функция объявлена ​​внутри него. Когда нам приходится работать с данными строкового типа, необходим заголовочный файл «строка».



После этого под этими заголовочными файлами добавляется пространство имен std. Затем мы создаем здесь класс. Имя класса — «Перемещение». Ниже добавляется ключевое слово «private», в котором мы объявляем частную строковую переменную с именем «my_str». Теперь мы помещаем ключевое слово public туда, где добавляем определение конструктора по умолчанию. Мы передаем «Это строка по умолчанию» в «my_str» в качестве параметра и оставляем конструктор по умолчанию пустым.



После этого мы копируем определение конструктора и инициализируем «my_str» как «my_obj.my_str». Ниже мы печатаем строку, а затем помещаем определение конструктора «перемещения». Здесь мы снова инициализируем «my_str» с помощью «my_obj.my_str». Мы не добавляем никаких утверждений ниже этого; оно пусто. После этого мы объявляем функцию с именем «displayMyObject()» строкового типа и используем «return str», чтобы она возвращала строку.





Помещаем глобальную функцию new_temp в тип move. Ниже находится «return temp», которая возвращает объект типа перемещения. Теперь мы помещаем код драйвера «main()» и «new_obj1» типа «move» и получаем конструктор «move» из «rvalue». В следующей строке мы помещаем «new_obj1.displayMyObject()», чтобы получить конструктор «перемещения» из «lvalue». После этого мы вызываем конструктор «move» с объектом «my_obj1». Затем мы передаем право собственности на «my_obj1» другому объекту — «my_obj2».

Код 1:

#include

#include <строка>

с использованием пространство имен стандартный ;

сорт Двигаться

{

частный :
строка my_str ;
общественный :
Двигаться ( ) : моя_стр ( «Здесь это строка по умолчанию» )
{
}
Двигаться ( константа Двигаться & мой_объект ) : моя_стр ( мой_объект. моя_стр )
{


расчет << «Вызван конструктор копирования, не удалось выполнить перемещение! \п ' ;

}
Двигаться ( Двигаться && мой_объект ) : моя_стр ( двигаться ( мой_объект. моя_стр ) )
{
}
строка displayMyObject ( )
{
возвращаться моя_стр ;
}
} ;
Переместить new_temp ( Переместить темп )
{
возвращаться tmp ;
}
интервал основной ( )
{
Переместить новый_obj1 '=' новая_темп ( Двигаться ( ) ) ;


расчет << 'перед вызовом move(): new_obj1 = ' << новый_obj1. дисплейМойОбъект ( ) << конец ;

Переместить new_obj2 '=' двигаться ( новый_obj1 ) ;

расчет << 'после вызова конструктора move(): new_obj1 = ' << новый_obj1. дисплейМойОбъект ( ) << конец ;

расчет << 'после вызова конструктора move(): new_obj2 = ' << новый_obj2. дисплейМойОбъект ( ) << конец ;

возвращаться 0 ;

}

Выход:

Вывод показывает, что перед вызовом метода «move()» «new_obj1» содержит строку по умолчанию. Но после вызова метода move() класса «Move» «my_obj1» содержит пустую строку, а «my_obj2» — строку по умолчанию.



Пример 2:

Здесь мы включаем еще один заголовочный файл, который является «векторным» заголовочным файлом. Мы включаем это всякий раз, когда нам нужно манипулировать операциями с векторами. Класс, который мы здесь создаем, — это класс «Перемещение». Здесь мы также создаем «публичный» конструктор, в котором объявляем необработанный указатель «int* value» как данные члена класса. Ниже у нас есть «public», в который мы помещаем конструктор «Move» и передаем «int v1» в качестве его параметра.

После этого мы объявляем объекты в куче. Мы инициализируем «значение» «new int», а «*value» — «v1». Затем поместите «cout» туда, где мы добавляем строку, которая печатается при выполнении кода. Ниже мы используем конструктор «копирования». Этот конструктор «копирования» копирует данные, создавая глубокую копию. Мы размещаем конструктор «Move» и передаем «Move&& new_source» в качестве его параметра. Под ним мы размещаем «cout», который помогает отобразить требуемый оператор.

Мы вставляем ключевое слово nullptr, чтобы определить, является ли указатель пустым перед использованием ссылки. Теперь мы также размещаем деструктор «~Move()», в который помещаем условие «if», которое проверяет, не равно ли «значение» «nullptr». Когда это условие проверено, выполняется приведенный ниже оператор. Если это условие не проверено, оно пропускает оператор «cout», который присутствует после условия «if», и переходит к части «else».

После этого мы используем ключевое слово «delete», которое помогает освободить объект или, можно сказать, освобождает память, выделенную для компонента данных объекта. Теперь мы вызываем здесь метод «main()» и создаем вектор нашего класса «Move» с именем «my_vec». После этого мы используем функцию push_back(), которая помогает вставить значение в конечную точку вектора. Заголовочный файл «вектор» содержит эту функцию. Сначала вставляем в вектор «39». Затем вставляется «57», а также «91» с использованием метода «push_back()».

Код 2:

#include

#include <вектор>

с использованием пространство имен стандартный ;

сорт Двигаться {

частный :
интервал * ценить ;
общественный :
Двигаться ( интервал v1 )
{
ценить '=' новый интервал ;
* ценить '=' v1 ;

расчет << «Конструктор призван»

<< v1 << конец ;

} ;
Двигаться ( константа Двигаться & новый_источник )
: Двигаться { * новый_источник. ценить }
{


расчет << «Конструктор копирования называется -»

<< «Глубокая копия для»

<< * новый_источник. ценить

<< конец ;

}
Двигаться ( Двигаться && новый_источник )
: ценить { новый_источник. ценить }
{


расчет << «Переместить конструктор для»

<< * новый_источник. ценить << конец ;

новый_источник. ценить '=' нульптр ;

}
~Переместить ( )
{
если ( ценить ! '=' нульптр )


расчет << 'Вызывается деструктор'

<< * ценить << конец ;

еще

расчет << «Вызывается деструктор»

<< 'для nullptr'

<< конец ;

удалить ценить ;

}

} ;

интервал основной ( )

{

вектор < Двигаться > моя вещь ;

моя вещь. отталкивать ( Двигаться { 39 } ) ;
моя вещь. отталкивать ( Двигаться { 57 } ) ;
моя вещь. отталкивать ( Двигаться { 91 } ) ;
возвращаться 0 ;


}

Выход:

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

Заключение

В этом руководстве мы рассмотрели конструктор «перемещения». Мы объяснили, что конструктор «перемещения» в программировании на C++ — это уникальный метод эффективного перемещения ресурсов одного объекта в другой объект. Мы обсуждали, что вызов конструктора «move» требует меньше накладных расходов, что делает код более эффективным с точки зрения использования памяти. Мы рассмотрели тот факт, что конструктор перемещения — мощная функция программирования на C++. Мы также использовали практические примеры для иллюстрации концепции конструктора перемещения и продемонстрировали преимущества производительности от использования конструктора перемещения в программировании на C++.