编辑:它不是重复,因为这个问题询问编译器在O0中的决定.
据说这里是名称返回值优化(NRVO)是一个优化许多编译器的支持.但它是必须的还是只是一个很好的优化？
我的情况是,我想编译-O0(即没有优化),以方便调试,但我也希望NRVO启用返回对象(例如,向量)的返回语句.如果NRVO不是必须的,编译器可能不会在-O0模式下执行.在这种情况下,我应该更喜欢这个代码:
std::vector<int> foo() {
std::vector<int> v(100000,1); // an object that is really big..
return std::move(v); // explicitly move
}
在这下面？
std::vector<int> foo() {
std::vector<int> v(100000,1);
return v; // copy or move?
}
编辑:我使用的编译器是GCC6,但我希望代码与编译器无关.
如果我们写如下函数：
auto foo() {
Foo foo { /* ... */ };
do_stuff(foo);
return foo;
}
然后NRVO应该启动，这样foo就不会在返回时被复制。
现在假设我想返回两个不同的值：
auto foo() {
Foo foo { /* ... */ };
Bar bar { /* ... */ };
do_stuff(foo, bar);
return std::make_tuple(foo, bar);
}
这种幼稚的实现可能会触发构建每个Foo和Bar( GodBolt)的两个副本。
我应该如何最好地修改我的代码以避免这种复制，而不会弄乱我的返回类型？
我试图了解 std::move 。在我的代码中，我正在从内部包含两个字段的std::list<struct Data>位置移动一个元素，但我没有得到预期的输出。这是我的代码：struct Datastd::string
#include <iostream>
#include <string>
#include <list>
struct Data {
std::string topic {};
std::string msg {};
Data(const std::string& topic, const std::string& msg) {
this->topic = topic;
this->msg = msg;
}
};
int main() {
std::list<Data> data_list;
data_list.push_back(Data("A", std::string(1000, 'a')));
data_list.push_back(Data("B", std::string(1000, 'b')));
data_list.push_back(Data("C", std::string(1000, 'c')));
data_list.push_back(Data("D", std::string(1000, 'd')));
data_list.push_back(Data("E", std::string(1000, 'e')));
while (!data_list.empty()) {
std::cout << (void*)&data_list.front() << "\n";
Data&& d1 = std::move(data_list.front());
data_list.pop_front();
std::cout << d1.topic << ", " << d1.msg …为什么我不能std::unique_ptr使用std::move语义（我认为）返回包含 , 的类，如下例所示？我认为 return 会调用 class 的 move ctor A，这将std::move是std::unique_ptr. （我使用的是 GCC 11.2，C++20）
例子：
#include <memory>
class A {
public:
explicit A(std::unique_ptr<int> m): m_(std::move(m)) {}
private:
std::unique_ptr<int> m_;
};
A makit(int num) {
auto m = std::make_unique<int>(num);
return std::move(A(m)); // error: use of deleted function 'std::unique_ptr<_Tp, _Dp>::unique_ptr(const std::unique_ptr<_Tp, _Dp>&) [with _Tp = int; _Dp = std::default_delete<int>]'x86-64 gcc 11.2 #1
}
int main() {
auto a = makit(42);
return 0;
}
我相信解决方案是返回 …
为什么std::move()在这种情况下会导致SEGFAULT？
#include <iostream>
struct Message {
std::string message;
};
Message * Message_Init(std::string message) {
Message * m = (Message*)calloc(1, sizeof(Message));
m->message = std::move(message);
return m;
}
int main() {
auto m = Message_Init("Hello");
return 0;
}
PS请不要问为什么Message不以通常的 C++ 方式构造。
我使用std::unique_ptr自定义删除器作为a的值,std::map如下所示:
#include <iostream>
#include <memory>
#include <map>
void deleter(int* p){
std::cout<<"Deleting..."<<std::endl;
delete p;
}
int main()
{
std::map<char, std::unique_ptr<int, void(*)(int*)>> a;
std::unique_ptr<int, void(*)(int*)> p{new int{3}, deleter};
a['k'] = std::move(p);
}
插入值时,我使用std::move,但不会编译.
我究竟做错了什么？
您会在链接后看到错误.
当我做int a = std :: move(b)(b也是int)时,它是否与a = b相同？
我正在研究一个开源应用程序的代码。我制作了这段代码的一个更简单的版本，以隔离困扰我的问题（尽管我对这段代码有几个问题，我希望 C++ 专家能够帮助我，我将从主要问题开始）。
主要思想（参见下面的代码）是将 Variant 类的实例分配给 a std::map（其键是 a std::string）。这是代码：
#include <iostream>
#include <map>
#include <string>
#include <memory>
struct Data
{
public:
Data(const void* data, size_t bytes) : bytes(bytes)
{
ptr = malloc(bytes);
memcpy(ptr, data, bytes);
std::cout << "in ctor of Data" << std::endl;
}
~Data() { free(ptr); std::cout << "in dtor of Data" << std::endl; }
void* ptr{ nullptr };
size_t bytes;
};
struct DataStream
{
public:
DataStream(const std::shared_ptr<Data>& ptr, size_t size) : ptr(ptr), …