- C++11 的值类别包括左值(lvalue)、纯右值(prvalue)、亡值(xvalue),左值和亡值组成了泛左值(glvalue),纯右值和亡值组成了右值(rvalue)。为了让编译器识别接受右值作为参数的构造函数,则需要引入右值引用符号(&&),以区分移动构造函数和拷贝构造函数
#include <cassert>
#include <string>
#include <utility>
#include <vector>
namespace jc {
struct A {
A() : data(new std::string) {}
A(const A& rhs) : data(new std::string{*rhs.data}) {}
A(A&& rhs) noexcept : data(rhs.data) { rhs.data = nullptr; }
~A() { delete data; }
std::string* data = nullptr;
};
} // namespace jc
int main() {
std::vector<jc::A> v;
v.emplace_back(jc::A{}); // 调用默认构造函数、移动构造函数、析构函数
jc::A a;
v.emplace_back(a); // 调用拷贝构造函数
assert(a.data);
v.emplace_back(std::move(a)); // 调用移动构造函数
assert(!a.data);
}
- 右值引用即只能绑定到右值的引用,字面值(纯右值)和临时变量(亡值)就是常见的右值。如果把左值传递给右值引动参数,则需要强制类型转换,std::move 就是不需要显式指定类型的到右值引用的强制类型转换
#include <cassert>
#include <string>
#include <type_traits>
#include <utility>
namespace jc {
template <typename T>
constexpr std::remove_reference_t<T>&& move(T&& x) noexcept {
return static_cast<std::remove_reference_t<T>&&>(x);
}
constexpr int f(const std::string&) { return 1; }
constexpr int f(std::string&&) { return 2; }
} // namespace jc
int main() {
std::string s;
static_assert(jc::f(s) == 1);
assert(jc::f(std::string{}) == 2);
static_assert(jc::f(static_cast<std::string&&>(s)) == 2);
static_assert(jc::f(jc::move(s)) == 2);
static_assert(jc::f(std::move(s)) == 2);
}
- 右值引用是能接受右值的引用,引用可以取址,是左值,因此右值引用是左值。如果一个函数接受右值引用参数,把参数传递给其他函数时,会按左值传递,这样就丢失了原有的值类别
#include <cassert>
#include <string>
#include <utility>
namespace jc {
constexpr int f(const std::string&) { return 1; }
constexpr int f(std::string&&) { return 2; }
constexpr int g(std::string&& s) { return f(s); }
void test() {
std::string s;
assert(f(std::string{}) == 2);
assert(g(std::string{}) == 1);
static_assert(f(std::move(s)) == 2);
static_assert(g(std::move(s)) == 1);
}
} // namespace jc
int main() { jc::test(); }
#include <cassert>
#include <string>
#include <utility>
namespace jc {
constexpr int f(std::string&) { return 1; }
constexpr int f(const std::string&) { return 2; }
constexpr int f(std::string&&) { return 3; }
constexpr int g(std::string& s) { return f(s); }
constexpr int g(const std::string& s) { return f(s); }
constexpr int g(std::string&& s) { return f(std::move(s)); }
void test() {
std::string s;
const std::string& s2 = s;
static_assert(g(s) == 1);
assert(g(s2) == 2);
static_assert(g(std::move(s)) == 3);
assert(g(std::string{}) == 3);
}
} // namespace jc
int main() { jc::test(); }
- 模板参数中右值引用符号表示的是万能引用(universal reference),因为模板参数本身可以推断为引用,它可以匹配几乎任何类型(少部分特殊类型无法匹配,如位域),传入左值时推断为左值引用类型,传入右值时推断为右值引用类型。对万能引用参数使用 std::forward 则可以保持值类别不丢失,这种保留值类别的转发手法就叫完美转发,因此万能引用也叫转发引用(forwarding reference)
#include <cassert>
#include <string>
#include <type_traits>
namespace jc {
template <typename T>
constexpr T&& forward(std::remove_reference_t<T>& t) noexcept {
return static_cast<T&&>(t);
}
constexpr int f(std::string&) { return 1; }
constexpr int f(const std::string&) { return 2; }
constexpr int f(std::string&&) { return 3; }
template <typename T>
constexpr int g(T&& s) {
return f(jc::forward<T>(s)); // 等价于 std::forward
}
void test() {
std::string s;
const std::string& s2 = s;
static_assert(g(s) == 1); // T = T&& = std::string&
assert(g(s2) == 2); // T = T&& = const std::string&
static_assert(g(std::move(s)) == 3); // T = std::string, T&& = std::string&&
assert(g(std::string{}) == 3); // T = T&& = std::string&
assert(g("downdemo") == 3); // T = T&& = const char (&)[9]
}
} // namespace jc
int main() { jc::test(); }
#include <iostream>
#include <string>
#include <type_traits>
#include <utility>
namespace jc {
template <typename F, typename... Args>
constexpr void constexpr_for(F&& f, Args&&... args) {
(std::invoke(std::forward<F>(f), std::forward<Args>(args)), ...);
}
template <typename... Args>
void print(Args&&... args) {
constexpr_for([](const auto& x) { std::cout << x << std::endl; },
std::forward<Args>(args)...);
}
} // namespace jc
int main() { jc::print(3.14, 42, std::string{"hello"}, "world"); }
- Lambda 中使用完美转发需要借助 decltype 推断类型
#include <iostream>
#include <string>
#include <type_traits>
#include <utility>
namespace jc {
constexpr auto constexpr_for = [](auto&& f, auto&&... args) {
(std::invoke(std::forward<decltype(f)>(f),
std::forward<decltype(args)>(args)),
...);
};
auto print = [](auto&&... args) {
constexpr_for([](const auto& x) { std::cout << x << std::endl; },
std::forward<decltype(args)>(args)...);
};
} // namespace jc
int main() { jc::print(3.14, 42, std::string{"hello"}, "world"); }
#include <iostream>
#include <string>
#include <type_traits>
#include <utility>
namespace jc {
constexpr auto constexpr_for =
[]<typename F, typename... Args>(F&& f, Args&&... args) {
(std::invoke(std::forward<F>(f), std::forward<Args>(args)), ...);
};
auto print = []<typename... Args>(Args&& ... args) {
constexpr_for([](const auto& x) { std::cout << x << std::endl; },
std::forward<Args>(args)...);
};
} // namespace jc
int main() { jc::print(3.14, 42, std::string{"hello"}, "world"); }
#include <iostream>
#include <string>
#include <type_traits>
#include <utility>
namespace jc {
template <typename... Args>
void print(Args&&... args) {
[... args = std::forward<Args>(args)]<typename F>(F&& f) {
(std::invoke(std::forward<F>(f), args), ...);
}([](const auto& x) { std::cout << x << std::endl; });
}
} // namespace jc
int main() { jc::print(3.14, 42, std::string{"hello"}, "world"); }
- 模板也能用于构造函数,但它不是真正的构造函数,从函数模板实例化而来的函数不和普通函数等价,由成员函数模板实例化的函数不会重写虚函数,由构造函数模板实例化的构造函数不是拷贝或移动构造函数,但对一个 non-const 对象调用构造函数时,万能引用是更优先的匹配
#include <string>
#include <utility>
namespace jc {
struct A {
template <typename T>
explicit A(T&& t) : s(std::forward<T>(t)) {}
A(const A& rhs) : s(rhs.s) {}
A(A&& rhs) noexcept : s(std::move(rhs.s)) {}
std::string s;
};
} // namespace jc
int main() {
const jc::A a{"downdemo"};
jc::A b{a}; // OK,匹配拷贝构造函数
// jc::A c{b}; // 错误,匹配模板构造函数
}
#include <string>
#include <type_traits>
#include <utility>
namespace jc {
struct A {
template <typename T, // 要求 T 能转为 std::string
typename = std::enable_if_t<std::is_convertible_v<T, std::string>>>
explicit A(T&& t) : s(std::forward<T>(t)) {}
A(const A& rhs) : s(rhs.s) {}
A(A&& rhs) noexcept : s(std::move(rhs.s)) {}
std::string s;
};
} // namespace jc
int main() {
const jc::A a{"downdemo"};
jc::A b{a}; // OK,匹配拷贝构造函数
jc::A c{b}; // OK,匹配拷贝构造函数
}
#include <concepts>
#include <string>
#include <utility>
namespace jc {
struct A {
template <typename T>
requires std::convertible_to<T, std::string>
explicit A(T&& t) : s(std::forward<T>(t)) {}
A(const A& rhs) : s(rhs.s) {}
A(A&& rhs) noexcept : s(std::move(rhs.s)) {}
std::string s;
};
} // namespace jc
int main() {
const jc::A a{"downdemo"};
jc::A b{a}; // OK,匹配拷贝构造函数
jc::A c{b}; // OK,匹配拷贝构造函数
}