C++ 如何避免不必要的数据复制？

我的代码中有一个函数，它将一些向量作为参数，从它们生成一个结构，并将该结构推送到队列中。然后使用while循环，以以下方式处理队列：

如果找到满足某些预定义条件（条件1）的结构，则返回

true

如果满足某个预定义条件（条件2）的结构是 找到，放弃结构并继续

否则，将当前结构分解为多个结构，并将每个结构推送到队列中

最后，如果处理了整个队列，则返回

false

下面给出的代码工作正常，但我认为这段代码多次进行了不必要的复制

struct q_element {
    vector<vector<int> > formula;
    vector<int> assignments;
    vector<int> unknowns;
};

bool solve(vector<vector<int> > init_formula, vector<int> init_unknowns, vector<int> init_assignments) {
    q_element t = {init_formula, init_assignments, init_unknowns, };
    deque<q_element> q;
    q.push_back(t);

    while (!q.empty()) {
        t = q.front(); //1. Copy struct from queue to t
        q.pop_front();
        if(satisfiable(t)){
            return true;
        }else if(unsatisfiable(t){
            continue;
        }else{
        vector<int> set=generateSet(t.unknowns);
        for (int i = 0; i < set.size(); i++) {
            vector<int> term = set[i];
            vector <vector<int> > newFormula=findNewFormula(t.formula, term);
            vector<int> newAssignments=findNewAssignments(t.assignments, term);
            vector<int> newUnknowns=findnewUnknowns(t.unknowns, term);
            q_element temp={ newFormula, newAssignments, newUnknowns }//2. Copy vectors into struct
            q.push_back(temp);//3. Copy struct into queue
            }
        }
    }
    return false;
}

struct q_元素{
向量公式；
向量赋值；
向量未知数；
};
布尔解算（向量初始值公式、向量初始值未知数、向量初始值赋值）{
q_元素t={init_公式，init_赋值，init_未知数，}；
德克q；
q、 推回（t）；
而（！q.empty（））{
t=q.front（）；//1.将结构从队列复制到t
q、 pop_front（）；
if（可满足（t））{
返回true；
}否则如果（不可满足（t）{
继续；
}否则{
向量集=生成集（t.未知数）；
对于（int i=0；i

---

我的问题是，通过使用指针结构或引用结构，或使用结构指针队列或任何其他方式，可以避免这种不必要的复制吗？

您可以通过引用传递

q\u元素

：

bool solve(const q_element& t) { ... }

此“副本”：

可以通过始终在while循环结束时引用

q.front（）

而不是

t

和

q.pop\u front（）

来避免

恐怕需要第二份副本：

q_element temp={ newFormula, newAssignments, newUnknowns }//2. Copy vectors into struct

最后，对于C++11，最后一个“副本”：

将只是一个“移动”操作

还包括：

vector<int> term = set[i];
vector <vector<int> > newFormula=findNewFormula(t.formula, term);
vector<int> newAssignments=findNewAssignments(t.assignments, term);
vector<int> newUnknowns=findnewUnknowns(t.unknowns, term);
q_element temp={ newFormula, newAssignments, newUnknowns }//2. Copy vectors into struct
q.push_back(temp);//3. Copy struct into queue

---

你在使用C++11吗？在某些地方，你可以移动而不是复制，这效率更高。@AlanStokes，是的，我在使用C++11。除了通过引用传递

q_元素

，我还可以制作指针的结构来进一步减少复制吗？@bolov为什么这在C++11中很重要？嗯……就地创建比移动快。我同意howe无论如何，它应该不重要。它也更优雅（你不需要一个临时变量）。实际上，你写它的方式会复制，而不会移动，所以它确实很重要。它可以写为移动而不返回emplace，但正如我所说的，使用emplace更优雅，如果我们有它，为什么不使用它呢？@bolov添加了

emplace\u back

rewrite。

q.push_back(temp);//3. Copy struct into queue

vector<int> term = set[i];
vector <vector<int> > newFormula=findNewFormula(t.formula, term);
vector<int> newAssignments=findNewAssignments(t.assignments, term);
vector<int> newUnknowns=findnewUnknowns(t.unknowns, term);
q_element temp={ newFormula, newAssignments, newUnknowns }//2. Copy vectors into struct
q.push_back(temp);//3. Copy struct into queue

q.emplace_back(
    { findNewFormula(t.formula, set[i])
    , findNewAssignments(t.assignments, set[i])
    , findnewUnknowns(t.unknowns, set[i]) }
);