Semântica de movimento vs referência constante [duplicado]
minha classe tem variáveis de string e quero inicializá-las com valores passados para o construtor.
Meu professor pensou que passássemos strings como uma referência const:
MyClass::MyClass(const std::string &title){
this->title = title
}
No entanto, Clang-Tidy sugere usar o comando de movimento:
MyClass::MyClass(std::string title){
this->title = std::move(title)
}
Então, estou me perguntando qual é a maneira correta de fazer isso no C ++ moderno.
Eu já olhei em volta, mas nada realmente respondeu à minha pergunta. Desde já, obrigado!
Respostas
Nenhum é ideal, pois ambos constroem titleprimeiro e, em seguida, copiam a atribuição ou movem a atribuição. Use a lista de inicializadores de membros.
MyClass::MyClass(const std::string& title) : title(title) {} // #1
// or
MyClass::MyClass(std::string title) : title(std::move(title)) {} // #2
//or
MyClass::MyClass(const std::string& title) : title(title) {} // #3
MyClass::MyClass(std::string&& title) : title(std::move(title)) {} // #3
Vamos dar uma olhada neles e ver o que acontece no C++17:
# 1 - Um único construtor de conversão usando um arquivo const&.
MyClass::MyClass(const std::string& title) : title(title) {}
Isso criará 1 ou 2 std::strings de uma destas maneiras:
- O membro é uma cópia construída.
- A
std::stringé construído por umstd::stringconstrutor de conversão e, em seguida, o membro é copiado.
#2 - Um único construtor de conversão tomando um std::stringvalor by.
MyClass(std::string title) : title(std::move(title)) {}
Isso criará 1 ou 2 std::strings de uma destas maneiras:
- O argumento é construído pela otimização do valor de retorno de um temporário (
str1+str2) e, em seguida, o membro é movido. - O argumento é copiado e, em seguida, o membro é movido.
- O argumento é movido e, em seguida, o membro é movido.
- O argumento é construído por um
std::stringconstrutor de conversão e, em seguida, o membro é movido.
#3 - Combinando dois construtores de conversão.
MyClass(const std::string& title) : title(title) {}
MyClass(std::string&& title) : title(std::move(title)) {}
Isso criará 1 ou 2 std::strings de uma destas maneiras:
- O membro é uma cópia construída.
- O membro é movimento construído.
- A
std::stringé construído por umstd::stringconstrutor de conversão e, em seguida, o membro é movido.
Até agora, a opção #3parece ser a opção mais eficiente. Vamos verificar mais algumas opções.
Nº 4 - Como o nº 3, mas substituindo o construtor de conversão em movimento por um construtor de encaminhamento.
MyClass(const std::string& title) : title(title) {} // A
template<typename... Args>
explicit MyClass(Args&&... args) : title(std::forward<Args>(args)...) {} // B
Isso sempre criará 1 std::stringde uma destas maneiras:
- O membro é uma cópia construída via
A. - O membro é movido por meio de
B. - O membro é construído por um construtor
std::string(possivelmente convertendo) viaB.
#5 - Apenas um construtor de encaminhamento - removendo o construtor de conversão de cópia de #4.
template<typename... Args>
explicit MyClass(Args&&... args) : title(std::forward<Args>(args)...) {}
Isso sempre criará 1 std::stringcomo em #4, mas tudo é feito por meio do construtor de encaminhamento.
- O membro é uma cópia construída.
- O membro é movimento construído.
- O membro é construído por um construtor
std::string(possivelmente convertendo).
#6 - Um único argumento encaminhando o construtor de conversão.
template<typename T>
explicit MyClass(T&& title) : title(std::forward<T>(title)) {}
Isso sempre criará 1 std::stringcomo em #4 e #5, mas apenas pegará um argumento e o encaminhará ao std::stringconstrutor.
- O membro é uma cópia construída.
- O membro é movimento construído.
- O membro é construído por um
std::stringconstrutor de conversão.
A opção #6pode ser facilmente usada para fazer o encaminhamento perfeito se você quiser obter vários argumentos no MyClassconstrutor. Digamos que você tenha um intmembro e outro std::stringmembro:
template<typename T, typename U>
MyClass(int X, T&& title, U&& title2) :
x(X),
title(std::forward<T>(title)),
title2(std::forward<U>(title2))
{}
Copiar uma referência cria uma cópia da variável original (original e a nova estão em áreas diferentes), mover uma variável local converte para um rvalue sua variável local (e novamente, original e a nova estão em áreas diferentes).
Do ponto de vista do compilador, movepode ser (e é) mais rápido:
#include <string>
void MyClass(std::string title){
std::string title2 = std::move(title);
}
traduz para:
MyClass(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >): # @MyClass(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)
sub rsp, 40
mov rax, rdi
lea rcx, [rsp + 24]
mov qword ptr [rsp + 8], rcx
mov rdi, qword ptr [rdi]
lea rdx, [rax + 16]
cmp rdi, rdx
je .LBB0_1
mov qword ptr [rsp + 8], rdi
mov rsi, qword ptr [rax + 16]
mov qword ptr [rsp + 24], rsi
jmp .LBB0_3
.LBB0_1:
movups xmm0, xmmword ptr [rdi]
movups xmmword ptr [rcx], xmm0
mov rdi, rcx
.LBB0_3:
mov rsi, qword ptr [rax + 8]
mov qword ptr [rsp + 16], rsi
mov qword ptr [rax], rdx
mov qword ptr [rax + 8], 0
mov byte ptr [rax + 16], 0
cmp rdi, rcx
je .LBB0_5
call operator delete(void*)
.LBB0_5:
add rsp, 40
ret
No entanto,
void MyClass(std::string& title){
std::string title = title;
}
gera um código maior (semelhante ao GCC):
MyClass(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >&): # @MyClass(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >&)
push r15
push r14
push rbx
sub rsp, 48
lea r15, [rsp + 32]
mov qword ptr [rsp + 16], r15
mov r14, qword ptr [rdi]
mov rbx, qword ptr [rdi + 8]
test r14, r14
jne .LBB0_2
test rbx, rbx
jne .LBB0_11
.LBB0_2:
mov qword ptr [rsp + 8], rbx
mov rax, r15
cmp rbx, 16
jb .LBB0_4
lea rdi, [rsp + 16]
lea rsi, [rsp + 8]
xor edx, edx
call std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >::_M_create(unsigned long&, unsigned long)
mov qword ptr [rsp + 16], rax
mov rcx, qword ptr [rsp + 8]
mov qword ptr [rsp + 32], rcx
.LBB0_4:
test rbx, rbx
je .LBB0_8
cmp rbx, 1
jne .LBB0_7
mov cl, byte ptr [r14]
mov byte ptr [rax], cl
jmp .LBB0_8
.LBB0_7:
mov rdi, rax
mov rsi, r14
mov rdx, rbx
call memcpy
.LBB0_8:
mov rax, qword ptr [rsp + 8]
mov qword ptr [rsp + 24], rax
mov rcx, qword ptr [rsp + 16]
mov byte ptr [rcx + rax], 0
mov rdi, qword ptr [rsp + 16]
cmp rdi, r15
je .LBB0_10
call operator delete(void*)
.LBB0_10:
add rsp, 48
pop rbx
pop r14
pop r15
ret
.LBB0_11:
mov edi, offset .L.str
call std::__throw_logic_error(char const*)
.L.str:
.asciz "basic_string::_M_construct null not valid"
Então sim, std::moveé melhor (nessas circunstâncias).
Tudo bem, use uma referência const e, em seguida, use as listas de inicializadores de membros:
MyClass(const std::string &title) : m_title{title}
Onde m_title é sua string de membro na classe.
Você pode encontrar ajuda útil aqui: Listas de inicializadores de membros do construtor
existem 2 casos: lvalue ou rvalue de std::string.
na std::string const&versão, lvalue case é eficiente o suficiente, passado por referência e depois copiado . mas um rvalue será copiado em vez de movido , o que tem uma eficiência muito menor.
na std::stringversão, lvalue é copiado quando passado e movido para o membro. rvalue será movido duas vezes neste caso. mas geralmente é barato , o construtor de movimento.
além disso, na std::string&&versão, ele não pode receber um lvalue , mas rvalue é passado por referência e depois movido , melhor que movido duas vezes.
então, obviamente, é a melhor prática com ambos const&e &&, como o STL sempre faz. mas se mover o construtor for barato o suficiente, apenas passar por valor e mover também é aceitável.