我正在开发一个处理大量原子操作的项目。到目前为止，我还不知道\xe2\x80\x99t atomic_load()，并且仅依靠赋值运算符来获取原子类型的值，并且除了这么多测试之外，我还没有\xe2\x80\x99t看到错误。这些原子类型会被多个进程和线程以及 更改atomic_compare_exchange_strong_explicit()，因此它们每次都需要一个旧值，而 \xe2\x80\x99s 我总是这样做，oldValue = <Atomic_ type_variable>并且它总是工作正常。\n这只是偶然吗？我应该更喜欢使用atomic_load()吗？
这段代码是否有可能打印“两者都不是”？
using namespace std;
template<typename T>
void foo(T&& t) {
if constexpr (is_lvalue_reference_v<T>) {
cout << "lv" << endl;
} else if constexpr (is_rvalue_reference_v<T>) {
cout << "rv" << endl;
} else {
cout <<"neither" << endl;
}
}
我正在尝试更改我的代码以使用 std::move 按值获取向量，而不是按引用传递它，因为我已经收集到这样会更有效。不过，我已经看到了不同的方法，一种是让构造函数按值传递并在构造函数中使用 std::move，另一种方法是用 std::move 初始化类并让构造函数采用右值（我做对了吗？）。下面的一些例子：
方法一：
构造函数：
StatisticsCompiler::StatisticsCompiler(std::vector<Wrapper<StatisticsMC>> Inner_) :Inner(std::move(Inner_))
{
}
在主要：
vector<Wrapper<StatisticsMC>> gathererArray{ meanGatherer, absQuantileGatherer, relVaRGatherer, relESGatherer };
StatisticsCompiler gathererCombiner(gathererArray);
方法二。
构造函数：
StatisticsCompiler::StatisticsCompiler(std::vector<Wrapper<StatisticsMC>>&& Inner_) :Inner(Inner_)
{
}
主要的：
vector<Wrapper<StatisticsMC>> gathererArray{ meanGatherer, absQuantileGatherer, relVaRGatherer, relESGatherer };
StatisticsCompiler gathererCombiner(std::move(gathererArray));
这里发生的事情之间是否有区别，或者是同一件事，第一种方法在 main 中“看起来”更好，但第二种方法是我直观地理解它以学习右值的方式。如果在性能方面它们完全相同，那么标准做法是什么？
所以基本上我的问题是：我什么时候应该使用右值引用？在这个例子中，我正在处理一个记录器类（它只是将事情记录到控制台......）。我有不同的功能来记录不同日志级别的消息。他们接受一个 std::string 作为参数。我应该有每个函数的两个版本，第一个用于“正常”引用，第二个用于右值引用？
namespace lnr
{
class logger
{
public:
logger(const string& name);
logger(const string&& name);
~logger() = default;
const void trace(const string& message) const;
const void trace(const string&& message) const;
const void info(const string& message) const;
const void info(const string&& message) const;
const void warn(const string& message) const;
const void warn(const string&& message) const;
const void error(const string& message) const;
const void error(const string&& message) const;
private:
const string name;
};
}
因为用两者记录一些东西是很常见的
logger.trace("Hello");
和
std::string error_message = "..."; …std::vector::push_back.I有两个声明，rvalue并且lvalue在某种程度上。据我所知，几乎所有类型（T&?T&&?T）都可以转换为const T&，所以当不同类型的对象传递给编译器时，编译器会选择哪一种std::vector::push？
我是C++新手，虽然想了很多遍，还是想不通.
根据文档（http://www.cplusplus.com/reference/vector/vector/push_back/），它说：
void push_back (const value_type& val);
void push_back (value_type&& val);
在向量的末尾添加一个新元素，在其当前最后一个元素之后。val 的内容被复制（或移动）到新元素。
我的问题是我必须在复制常量数据和移动非常量数据之间做出选择，而且我从概念上看不出为什么在我的情况下将常量数据移动到常量目标是不安全的。我也知道从 const 对象移动是不合逻辑的 - 所以也许还有其他一些方法可以实现我正在尝试做的事情......
我有一个 Builder 类，它设置了一个我不想复制的 BigData 对象。构建器完成后，它会将数据“发出”为常量，因为在此之后不应对其进行修改。构建器是临时的，然后可以被丢弃，但数据应该继续存在，作为可以查询它的包装类中的 const 成员。builder 是一个泛型类型（不知道数据的细节），而 wrapper 是特定于数据内容的。这是通过数据中的类型擦除实现的，但这与此问题无关，只是要明确表示不希望合并构建器和包装器。
以下代码描述了上述内容，除非您删除 BigData 的移动构造函数，否则不会编译。编译错误表明这段代码会复制数据，这是不可取的：
prog.cpp:26:57: 错误：使用已删除的函数 'constexpr BigData::BigData(const BigData&)'
包装器（const BigData&& In）：数据（std::move（In））{}
^
class BigData
{
// Only a builder can create data
friend class Builder;
BigData() = default;
public:
// Move only
BigData( BigData&& ) = default;
};
class Builder
{
BigData Data;
public:
const BigData&& Build() & { return std::move(Data); }
// Functions to set up data go here
};
class Wrapper
{
const …我有一个模仿 std::vector 的类。为此，我想要一个函数 push_back 接受左值和右值。
void push_back(const T& obj) {
push_back(std::move(obj));
}
void push_back(T&& obj) {
buffer[numElements] = obj;
numElements = numElements+1>=Sz-1 ? Sz-1 : numElements+1;
}
但是，当我由于移动而传递左值时，此代码以无限递归结束，它调用了错误的函数（我希望const T& obj函数调用T&& obj重载）。
std::move 的文档说
它完全等同于 static_cast 到右值引用类型。
我错过了什么？
我有以下功能：
void func(void * const &ptr)
{
std::cerr << "const" << std::endl;
}
void func(void * &&ptr)
{
std::cerr << "mutable" << std::endl;
}
void* const func2()
{
return nullptr;
}
一个重载采用 const 引用参数，另一个采用可变右值引用。并且有一个返回 const 值的函数。
当我将该 const 临时值传递给函数时：
func(func2());
我希望选择 const 重载。但相反，我得到：
mutable
这怎么可能？为什么 const 返回值绑定到非 const rvalue 引用参数？
然而，当void*我将 const 传递struct给函数时，这不会发生：
struct A
{
};
void func(A const &a)
{
std::cerr << "const" << std::endl;
}
void func(A &&a)
{
std::cerr << "mutable" << …当编写具有返回类型的函数时，auto我们可以使用constexpr if返回不同的类型。
auto myfunc()
{
constexpr if (someBool)
{
type1 first = something;
return first;
}
else
{
type2 second = somethingElse;
return second;
}
}
然而，我正在努力弄清楚如何仅将其中一种类型作为参考。看来以下代码仍然返回两个分支的右值
auto myfunc()
{
constexpr if (someBool)
{
type1 &first = refToSomething;
return first;
}
else
{
type2 second = somethingElse;
return second;
}
}
有没有办法做到这一点？谷歌并没有透露太多，因为有很多关于自动和引用返回的更一般使用的教程。在我的特定情况下，该函数是一个类方法，我想返回对成员变量的引用或数组的视图。
在我的 std::list 中，我有 10 个元素，我想将数字 1000 移到列表的后面。
https://leetcode.com/playground/gucNuPit
有没有更好的方法，使用 std::move、后插入器或任何其他 C++ 语法的 1 行有意识地实现此目的？
// Move the number 1000 to the end of the list
#include <iostream>
#include <algorithm>
#include <list>
using namespace std;
int main() {
list<int> myList({2,3,4,1000,5,6,7,8,9,10});
cout << "List before " << endl;
for(auto e : myList)
cout << e << " ";
// get iterator to the number 1000 in the list
list<int>::iterator findIter = std::find(myList.begin(), myList.end(), 1000);
int val_to_move_to_end = *findIter;
myList.erase(findIter);
myList.push_back(val_to_move_to_end);
cout << …