Construtor de movimento C++

Construtor De Movimento C



A programação C++ é a melhor linguagem, pois nos facilita uma ampla gama de funções, construtores, arquivos de cabeçalho, classes e muito mais, tornando a codificação mais interessante e fácil. Um dos construtores na programação C++ é o construtor “move”. O construtor “move” é um tipo único de construtor que permite que a propriedade de uma memória alocada dinamicamente ou de outros recursos seja transferida de um objeto para outro de maneira eficaz e com uso consciente de recursos.

Na programação C++, construtores “move” foram introduzidos para reduzir a duplicação e aumentar a eficiência. Desempenha um papel crucial na melhoria do desempenho, minimizando as operações de cópia. Este guia explora profundamente o construtor “move” na programação C++.







Exemplo 1:

Para começar o código aqui, incluímos os arquivos de cabeçalho “iostream” e “string” que farão nosso código funcionar perfeitamente, já que muitas funções são declaradas nesses arquivos de cabeçalho. Quando temos que utilizar a instrução “cout”, o arquivo de cabeçalho “iostream” é utilizado, pois esta função é declarada dentro dele. Quando temos que trabalhar com dados do tipo string, o arquivo de cabeçalho “string” é necessário.



Depois disso, o “namespace std” é adicionado abaixo desses arquivos de cabeçalho. Então, construímos uma classe aqui. O nome da classe é “Mover”. Abaixo disso, a palavra-chave “private” é adicionada na qual declaramos uma variável de string privada com o nome “my_str”. Agora, colocamos a palavra-chave “public” onde adicionamos a definição do construtor padrão. Passamos “Esta é a string padrão aqui” para “my_str” como parâmetro e deixamos o construtor padrão vazio.



Depois disso, copiamos a definição do construtor e inicializamos “my_str” para “my_obj.my_str”. Abaixo disso, imprimimos uma linha e depois colocamos a definição do construtor “move”. Aqui, inicializamos “my_str” novamente com “my_obj.my_str”. Não adicionamos nenhuma declaração abaixo disso; ele está vazio. Depois disso, declaramos uma função chamada “displayMyObject()” do tipo string e utilizamos o “return str” para que ela retorne a string.





Colocamos a função global “new_temp” no tipo “move”. Abaixo dele, temos o “return temp” que retorna o objeto do tipo move. Agora, colocamos o código do driver “main()” e o “new_obj1” do tipo “move” e obtemos o construtor “move” do “rvalue”. Na linha a seguir, colocamos “new_obj1.displayMyObject()” para obter o construtor “move” do “lvalue”. Depois disso, chamamos o construtor “move” com o objeto “my_obj1”. Em seguida, transferimos a propriedade de “my_obj1” para o outro objeto que é “my_obj2”.

Código 1:

#include

#incluir

usando espaço para nome padrão ;

aula Mover

{

privado :
string meu_str ;
público :
Mover ( ) : meu_str ( 'Esta é a string padrão aqui' )
{
}
Mover ( const Mover & meu_obj ) : meu_str ( meu_obj. meu_str )
{


corte << 'Construtor de cópia invocado, falha na movimentação! \n ' ;

}
Mover ( Mover && meu_obj ) : meu_str ( mover ( meu_obj. meu_str ) )
{
}
string displayMyObject ( )
{
retornar meu_str ;
}
} ;
Mover new_temp ( Mover tmp )
{
retornar tmp ;
}
interno principal ( )
{
Mover novo_obj1 = nova_temp ( Mover ( ) ) ;


corte << 'antes da chamada move(): new_obj1 =' << novo_obj1. displayMyObject ( ) << fim ;

Mover novo_obj2 = mover ( novo_obj1 ) ;

corte << 'após a chamada do construtor move(): new_obj1 =' << novo_obj1. displayMyObject ( ) << fim ;

corte << 'após a chamada do construtor move(): new_obj2 =' << novo_obj2. displayMyObject ( ) << fim ;

retornar 0 ;

}

Saída:

A saída mostra que antes de chamar o método “move()”, o “new_obj1” contém a string padrão. Mas depois de chamar o método move() da classe “Move”, “my_obj1” contém uma string vazia e “my_obj2” tem a string padrão.



Exemplo 2:

Aqui, incluímos mais um arquivo de cabeçalho que é o arquivo de cabeçalho “vetorial”. Incluímos isso sempre que tivermos que manipular as operações nos vetores. A classe que criamos aqui é a classe “Move”. Também criamos um construtor “público” aqui no qual declaramos o ponteiro bruto “int* value” como sendo os dados de um membro da classe. Abaixo dele temos o “público” no qual colocamos o construtor “Move” e passamos “int v1” como parâmetro.

Depois disso, declaramos os objetos em um heap. Inicializamos o “valor” com “new int” e o “*valor” com “v1”. Em seguida, coloque o “cout” onde adicionamos uma linha que será impressa quando executarmos o código. Abaixo disso, utilizamos o construtor “copy”. Este construtor “copy” copia os dados fazendo uma cópia profunda. Colocamos o construtor “Move” e passamos “Move&& new_source” como seu parâmetro. Abaixo dele colocamos o “cout” que auxilia na exibição do enunciado solicitado.

Inserimos a palavra-chave “nullptr” para determinar se um ponteiro está vazio antes da referência ser utilizada. Agora, colocamos também o destruidor “~Move()” no qual colocamos a condição “if” que verifica se o “valor” não é igual a “nullptr”. Quando esta condição é verificada, a instrução abaixo desta é executada. Se esta condição não for verificada, ele pula a instrução “cout” que está presente após a condição “if” e avança para a parte “else”.

Depois disso, utilizamos a palavra-chave “delete” que auxilia na desalocação de um objeto ou podemos dizer que libera a memória que está alocada para o componente de dados do objeto. Agora, invocamos o método “main()” aqui e criamos o vetor de nossa classe “Move” com o nome “my_vec”. Depois disso, utilizamos a função “push_back()” que ajuda a inserir um valor na extremidade de um vetor. O arquivo de cabeçalho “vetorial” contém esta função. Primeiro, inserimos “39” no vetor. Em seguida, “57” é inserido e “91” também é inserido utilizando o método “push_back()”.

Código 2:

#include

#incluir

usando espaço para nome padrão ;

aula Mover {

privado :
interno * valor ;
público :
Mover ( interno v1 )
{
valor = novo interno ;
* valor = v1 ;

corte << 'O Construtor é chamado'

<< v1 << fim ;

} ;
Mover ( const Mover & nova fonte )
: Mover { * nova fonte. valor }
{


corte << 'Construtor de cópia é chamado -'

<< 'Cópia profunda para'

<< * nova fonte. valor

<< fim ;

}
Mover ( Mover && nova fonte )
: valor { nova fonte. valor }
{


corte << 'Mover construtor para'

<< * nova fonte. valor << fim ;

nova fonte. valor = nullptr ;

}
~ Mover ( )
{
se ( valor ! = nullptr )


corte << 'Destruidor é chamado'

<< * valor << fim ;

outro

corte << 'Destruidor é chamado'

<< 'para nullptr'

<< fim ;

excluir valor ;

}

} ;

interno principal ( )

{

vetor < Mover > minha coisa ;

minha coisa. retrocesso ( Mover { 39 } ) ;
minha coisa. retrocesso ( Mover { 57 } ) ;
minha coisa. retrocesso ( Mover { 91 } ) ;
retornar 0 ;


}

Saída:

Isso mostra que em vez de usar a função “copiar”, temos que utilizar a função “mover” para evitar a chamada desnecessária à função “copiar”. O construtor “move” é invocado aqui quando inicializamos o objeto com um objeto temporário ou algum objeto que será destruído. Em vez de manipular uma cópia profunda dos dados fornecidos, o construtor “move” transfere a propriedade dos recursos de um objeto para outro.

Conclusão

Neste guia, exploramos o construtor “move”. Explicamos que o construtor “move” na programação C++ é um método único para realocar os recursos de um objeto para outro objeto de forma eficaz. Discutimos que chamar o construtor “move” tem menos sobrecarga, tornando o código mais eficiente em termos de memória. Exploramos o fato de que o construtor “move” é um recurso poderoso na programação C++. Também utilizamos os exemplos práticos para ilustrar o conceito do construtor “move” e demonstramos os benefícios de desempenho da utilização do construtor “move” na programação C++.