C++ 避免使用c++；矢量拷贝

我想避免复制一个相当大的向量。这里有一个非常清楚的例子来说明问题所在：

struct MyStruct {
    std::vector<int> v;
    int x;
}

class MyClass {
    MyStruct lastStruct_;
public:
    MyStruct create_struct() {
        MyStruct s = { std::vector<int>(1000000, 1), 1234 };
        lastStruct_ = s;  // THIS IS A FULL COPY, PROBLEM
        return s; // THIS SHOULD NOT BE A COPY AS PER C++11 AND UP
    }
    MyStruct getLastStruct() {
            return lastStruct_;
    }
}

void main()
{
    MyClass c;
  for (int i = 0; i < A_LOT; i++)
  {
    writeToDisk(c.create_struct());
  }
  //MEANWHILE IN OTHER THREAD:
  // while(true)
  //   updateUI(c.getLastStruct());
}

struct MyStruct{
std：：向量v；
int x；
}
类MyClass{
MyStruct lastStruct；
公众：
MyStruct create_struct（）{
MyStruct s={std:：vector（1000000，1），1234}；
lastStruct_uz=s；//这是完整副本，有问题
返回s；//根据C++11及更高版本，这不应是副本
}
MyStruct getLastStruct（）{
返回lastStruct；
}
}
void main（）
{
MyClass c；
for（int i=0；i

我怎样才能避免在这里复制？我试图用共享指针解决这个问题，但我对这些还是新手。是否需要此工作（语法可能已关闭）

struct MyStruct{
std：：向量v；
int x；
}
类MyClass{
std:：shared\u ptr lastStruct；
公众：
MyStruct create_struct（）{
auto s=std:：maked_shared（{std:：vector（1000000，1），1234}）；
lastStruct_uuz=s；
返回*s；
}
std:：shared_prt getLastStruct（）{
返回lastStruct；
}
}
void main（）
{
MyClass c；
for（int i=0；idata（））；
}

以下是最明显的方法：

struct MyStruct {
    std::vector<int> v;
    int x;
}

class MyClass {
    std::shared_ptr<MyStruct> lastStruct_;
public:
    std::shared_ptr<const MyStruct> create_struct() {
        auto s = std::maked_shared<MyStruct>({ std::vector<int>(1000000, 1), 1234 });
        // acquire lock
        lastStruct_ = s;
        // release lock
        return s; 
    }
    std::shared_ptr<const MyStruct> getLastStruct() {
        // acquire lock
        auto j = lastStruct_;
        // release lock
        return j;
    }
}

void main()
{
  MyClass c;
  for (int i = 0; i < A_LOT; i++)
  {
    auto j = c.create_struct();
    writeToDisk(*j);
  }
  //MEANWHILE IN OTHER THREAD:
  // while(true)
  // {
  //   auto j = c.getLastStruct();
  //   updateUI(j->data());
  // }
}

struct MyStruct{
std：：向量v；
int x；
}
类MyClass{
std:：shared\u ptr lastStruct；
公众：
std:：shared_ptr create_struct（）{
auto s=std:：maked_shared（{std:：vector（1000000，1），1234}）；
//获取锁
lastStruct_uuz=s；
//释放锁
返回s；
}
std:：shared_ptr getLastStruct（）{
//获取锁
自动j=最后一个结构；
//释放锁
返回j；
}
}
void main（）
{
MyClass c；
for（int i=0；idata（））；
// }
}

请注意，我们通过将指向旧对象的共享指针替换为指向新对象的共享指针来替换对象。访问旧对象的代码会使它保持活动状态，直到处理完为止

---

您需要某种类型的锁来保护

lastStruct\uu

在一个线程中被修改，而在另一个线程中被访问。

我只想指出，到目前为止，写入磁盘将是比复制向量更大的性能瓶颈。您确定正在优化程序的适当部分吗？当您对代码运行性能评测时，这是否显示为一个问题？是否有原因将其存储在lastStruct\ux中？如果是这样的话，你是想在create_struct而不是创建的s上返回它吗？很遗憾，是的，数据必须写入磁盘，这就是为什么它是在一个单独的线程上完成的。好的，所以我非常接近。事实上，为了使这个线程安全，还需要添加一些东西。你能详细解释一下为什么不在get方法中简单地返回lastStruct_uuu吗？@XDD因为

lastStruct_uuu

可能会在另一个线程中被修改。一个线程对可能被另一个线程修改的对象的引用可能会做什么？我们需要给线程提供它自己的共享指针，指向一个不能更改的对象，这样它就可以安全地使用它了。为了确保我明白这一点：如果lastStruct_uu被修改，那将是因为在其中创建并复制了指向其他地址的新指针。同时，新创建的

j

仍将指向包含未触及数据的旧lastStruct_uu地址。当J超出范围时，没有共享指针将指向该地址，因此C++最终将删除它。这是正确的吗？谢谢你的详细介绍explanations@XDD你明白了。

struct MyStruct {
    std::vector<int> v;
    int x;
}

class MyClass {
    std::shared_ptr<MyStruct> lastStruct_;
public:
    std::shared_ptr<const MyStruct> create_struct() {
        auto s = std::maked_shared<MyStruct>({ std::vector<int>(1000000, 1), 1234 });
        // acquire lock
        lastStruct_ = s;
        // release lock
        return s; 
    }
    std::shared_ptr<const MyStruct> getLastStruct() {
        // acquire lock
        auto j = lastStruct_;
        // release lock
        return j;
    }
}

void main()
{
  MyClass c;
  for (int i = 0; i < A_LOT; i++)
  {
    auto j = c.create_struct();
    writeToDisk(*j);
  }
  //MEANWHILE IN OTHER THREAD:
  // while(true)
  // {
  //   auto j = c.getLastStruct();
  //   updateUI(j->data());
  // }
}