Ц++ Мове Цонструцтор

C Move Constructor



Ц++ програмирање је најбољи језик јер нам омогућава широк спектар функција, конструктора, датотека заглавља, класа и још много тога, чинећи кодирање занимљивијим и лакшим. Један од конструктора у Ц++ програмирању је конструктор „померања“. Конструктор „померања“ је јединствена врста конструктора који омогућава да се власништво над динамички додељеном меморијом или другим ресурсима пренесе са једног објекта на други на ефикасан начин и свестан ресурса.

У Ц++ програмирању уведени су конструктори „померања“ да би се смањило дуплирање и повећала ефикасност. Он игра кључну улогу у побољшању перформанси минимизирањем операција копирања. Овај водич детаљно истражује конструктор „померања“ у Ц++ програмирању.







Пример 1:

Да бисмо започели код овде, укључујемо датотеке заглавља „иостреам“ и „стринг“ које ће учинити да наш код ради савршено пошто су многе функције декларисане у овим датотекама заглавља. Када морамо да користимо наредбу „цоут“, користи се датотека заглавља „иостреам“, пошто је ова функција декларисана унутар овога. Када морамо да радимо са подацима типа стринг, неопходна је датотека заглавља „стринг“.



Након тога, 'намеспаце стд' се додаје испод ових датотека заглавља. Затим, овде конструишемо класу. Назив класе је „Мове“. Испод овога се додаје кључна реч „привате“ у којој декларишемо приватну стринг променљиву са именом „ми_стр“. Сада стављамо „јавну“ кључну реч где додајемо дефиницију подразумеваног конструктора. Проследимо „Ово је подразумевани стринг овде“ у „ми_стр“ као параметар и оставимо подразумевани конструктор празан.



После овога, копирамо дефиницију конструктора и иницијализујемо „ми_стр“ у „ми_обј.ми_стр“. Испод овога штампамо линију, а затим постављамо дефиницију конструктора „померање“. Овде поново иницијализујемо „ми_стр“ са „ми_обј.ми_стр“. Не додајемо никакву изјаву испод овога; Празно је. Након овога, декларишемо функцију под називом „дисплаиМиОбјецт()“ типа стринг и користимо „ретурн стр“ тако да враћа стринг.





Глобалну функцију „нев_темп“ стављамо у тип „мове“. Испод њега имамо „температуру повратка“ која враћа објекат типа покрета. Сада постављамо код драјвера „маин()“ и „нев_обј1“ типа „мове“ и добијамо „мове“ конструктор из „рвалуе“. У линију испред постављамо „нев_обј1.дисплаиМиОбјецт()“ да бисмо добили конструктор „мове“ из „лвалуе“. После овога, позивамо конструктор „мове“ са објектом „ми_обј1“. Затим преносимо власништво над „ми_обј1“ на други објекат који је „ми_обј2“.

Код 1:

#инцлуде <иостреам>

#инцлуде <стринг>

Користећи именског простора стд ;

класа Потез

{

приватни :
стринг ми_стр ;
јавности :
Потез ( ) : ми_стр ( „Ово је подразумевани стринг овде“ )
{
}
Потез ( конст Потез & ми_обј ) : ми_стр ( ми_обј. ми_стр )
{


цоут << „Позван конструктор копирања, померање није успело! ' ;

}
Потез ( Потез && ми_обј ) : ми_стр ( потез ( ми_обј. ми_стр ) )
{
}
стринг дисплаиМиОбјецт ( )
{
повратак ми_стр ;
}
} ;
Помери нову_темп ( Мове тмп )
{
повратак тмп ;
}
инт главни ( )
{
Премести нови_обј1 = нев_темп ( Потез ( ) ) ;


цоут << 'пре позива () : нев_обј1 = ' << нови_обј1. дисплаиМиОбјецт ( ) << ендл ;

Премести нови_обј2 = потез ( нови_обј1 ) ;

цоут << 'после позива конструктора мове() : нев_обј1 = ' << нев_обј1. дисплаиМиОбјецт ( ) << ендл ;

цоут << 'после позива конструктора мове() : нев_обј2 = ' << нев_обј2. дисплаиМиОбјецт ( ) << ендл ;

повратак 0 ;

}

Излаз:

Излаз приказује да пре позивања методе „мове()“, „нев_обј1“ садржи подразумевани стринг. Али након позивања методе мове() класе „Мове“, „ми_обј1“ садржи празан стринг, а „ми_обј2“ има подразумевани стринг.



Пример 2:

Овде укључујемо још једну датотеку заглавља која је „векторска“ датотека заглавља. Ово укључујемо кад год морамо да манипулишемо операцијама на векторима. Класа коју овде креирамо је класа „Мове“. Овде такође креирамо „јавни“ конструктор у коме декларишемо сирови показивач „инт* валуе“ као податке члана класе. Испод њега имамо „публиц“ у који постављамо „Мове“ конструктор и проследимо „инт в1“ као његов параметар.

Након овога, објекте декларишемо у гомили. Иницијализујемо „вредност“ са „нев инт“ и „*валуе“ са „в1“. Затим поставите „цоут“ где додајемо линију која се штампа када извршимо код. Испод овога користимо конструктор „копирања“. Овај конструктор „копирања“ копира податке тако што прави дубоку копију. Постављамо конструктор „Мове“ и проследимо „Мове&& нев_соурце“ као његов параметар. Испод њега постављамо „цоут“ који помаже у приказивању потребне изјаве.

Убацујемо кључну реч „нуллптр“ да бисмо утврдили да ли је показивач празан пре него што се референца искористи. Сада такође постављамо деструктор „~Мове()“ у који постављамо услов „иф“ који проверава да ли „вредност“ није једнака „нуллптр“. Када је овај услов верификован, извршава се наредба испод. Ако овај услов није верификован, он прескаче наредбу „цоут“ која је присутна после услова „иф“ и креће се ка делу „елсе“.

Након тога, користимо кључну реч „делете“ која помаже у ослобађању објекта или можемо рећи да ослобађа меморију која је додељена компоненти података објекта. Сада, овде позивамо методу „маин()“ и креирамо вектор наше класе „Мове“ са именом „ми_вец“. Након тога, користимо функцију „пусх_бацк()“ која помаже да се уметне вредност на крајњу тачку вектора. Датотека заглавља „вектора“ садржи ову функцију. Прво, у вектор убацујемо „39“. Затим се убацује „57“ и „91“ се такође убацује коришћењем методе „пусх_бацк()“.

Код 2:

#инцлуде <иостреам>

#инцлуде <вектор>

Користећи именског простора стд ;

класа Потез {

приватни :
инт * вредност ;
јавности :
Потез ( инт в1 )
{
вредност = Нова инт ;
* вредност = в1 ;

цоут << 'Конструктор је позван за'

<< в1 << ендл ;

} ;
Потез ( конст Потез & нови_извор )
: Потез { * нови_извор. вредност }
{


цоут << 'Конструктор копирања се зове -'

<< „Дубина копија за“

<< * нови_извор. вредност

<< ендл ;

}
Потез ( Потез && нови_извор )
: вредност { нови_извор. вредност }
{


цоут << 'Конструктор померања за '

<< * нови_извор. вредност << ендл ;

нови_извор. вредност = нуллптр ;

}
~Мове ( )
{
ако ( вредност ! = нуллптр )


цоут << 'Деструктор је позван за'

<< * вредност << ендл ;

друго

цоут << 'Деструктор се зове'

<< 'за нуллптр'

<< ендл ;

избрисати вредност ;

}

} ;

инт главни ( )

{

вектор < Потез > моја ствар ;

моја ствар. потисне ( Потез { 39 } ) ;
моја ствар. потисне ( Потез { 57 } ) ;
моја ствар. потисне ( Потез { 91 } ) ;
повратак 0 ;


}

Излаз:

Ово показује да уместо да користимо функцију “цопи”, морамо да користимо функцију “мове” да бисмо спречили беспотребан позив функције “цопи”. Конструктор „померања“ се овде позива када иницијализујемо објекат привременим објектом или неким објектом који ће бити уништен. Уместо да манипулише дубоком копијом датих података, конструктор „померања“ пребацује власништво над ресурсима са једног објекта на други.

Закључак

У овом водичу смо истражили конструктор „померања“. Објаснили смо да је конструктор „померања“ у Ц++ програмирању јединствена метода за ефикасно премештање ресурса објекта у други објекат. Разговарали смо о томе да позивање конструктора „померања“ има мање трошкова, чинећи код ефикаснијим меморијом. Истражили смо чињеницу да је конструктор „померања“ моћна карактеристика у Ц++ програмирању. Такође смо користили практичне примере да илуструју концепт конструктора „померање“ и демонстрирали предности перформанси коришћења „померања“ конструктора у Ц++ програмирању.