相关疑难解决方法(0)

所以我试图在我的矢量背面添加整数,并错误地认为push_back()将新数据添加到矢量的前面(又名矢量[0]).我做了一个测试在Xcode和测试push_back()反对emplace_back(),并得到了相同的结果.我认为他们是不同的,但这让我觉得他们可能会做同样的事情.如果是这样,为什么矢量有不同的方法？

这是我的代码,以防我正在做的事情:

#include <vector>
#include <iostream> 

using namespace std ;

int main(int argc, const char * argv[])
{
    // for push_back
    vector<int> push;
    push.push_back(1);
    push.push_back(2);
    push.push_back(3);
    push.push_back(4);
    push.push_back(5);
    push.push_back(6);
    //display push_back
    for (int i = 0; i < push.size(); i++) {
        cout << "push[" << i  << "]: " << push[i] << endl;
    }
    // distance between the two funcitons
    cout << endl << endl;

    vector<int> emplace;
    emplace.emplace_back(1);
    emplace.emplace_back(2);
    emplace.emplace_back(3);
    emplace.emplace_back(4);
    emplace.emplace_back(5);
    emplace.emplace_back(6);

    //display …

<queue>的emplace和push 之间有什么区别？

这是关于std :: queue :: emplace和std :: queue :: push的解释 。

这两种方法都会在其当前最后一个元素return之后添加元素None。

除了使用emplace进行单次插入和使用向量中的insert进行多次插入之外,它们的实现还有其他不同之处吗？

在两种情况下,插入任何元素都会移动所有其他元素.

我想知道在将单个元素插入到STL容器中时是否可以始终使用emplace替换insert,例如set,unordered_set？

从签名,emplace更简单,不涉及重载.是否有任何问题一直停止使用insert和使用emplace？

注意:有些问题询问emplace和insert/ push_back等之间的区别(例如,这里,这里和这里)我理解差异,在我看来,emplace在各方面都更好.我只是想确认是否可以弃用insert.

这里和这里也存在类似的问题,但我认为我没有得到一个明确的答案然后我重新提出这个问题.

C++ 11标准有两种方法可以在向量的末尾添加一个新元素,它们是std :: vector :: push_back和std :: vector :: emplace_back.

它们之间的区别是std :: vector :: emplace_back构造对象到位,std :: vector :: push_back基本上复制对象(或基本类型)或将其移动到向量的末尾.

然后std :: vector :: push_back看起来更好的选择将原始类型添​​加到std :: vector中.例如:

std::vector<int> vVec;
vVec.push_back(10);
int iVar 30;
vVec.push_back(iVar);

但是当我们谈论对象时,我并不是那么清楚.我们以std :: string的向量为例.如果我想添加一个文字字符串,我将使用std :: vector :: emplace_back,当我想复制或移动一个字符串对象时,我将使用std :: vector :: push_back？

为了更清楚我要问的内容,让我们看几个场景:

第一种情况:

std::vector<string> vVec;
std::string sTest(“1st scenario”);
vVec.push_back(sTest);  
vVec.emplace_back(sTest); 

Push_back复制sTest并关联到vVec末尾的新元素,同时emplace_back在vVec的末尾创建字符串对象并将sTest的内容复制到其中.在这种情况下哪一个更有效或无关紧要？

第二种情况:

std::vector<string> vVec;
std::string sTest1(“2st scenario”);
std::string sTest2(“2st scenario”);
vVec.push_back(move(sTest1));   
vVec.emplace_back(move(sTest2)); 

Push_back已准备好移动语义,但emplace_back会发生什么？在这种情况下哪一个更有效？

第三种情况:

std::vector<string> vVec;
std::string sTest("3st scenario");
vVec.push_back(sTest.substr(4,4));
vVec.emplace_back(sTest.substr(4,4));

因为std :: …

制作仅移动类型的地图向量似乎在 Windows 上无法正常工作。请参阅此处的代码： https: //godbolt.org/z/yAHmzh

#include <vector>
#include <map>
#include <memory>

// vector<vector<move-only>> works
void foo() {
    std::vector<std::vector<std::unique_ptr<int>>> outer;
    std::vector<std::unique_ptr<int>> inner;
    std::unique_ptr<int> p = std::make_unique<int>(1);
    inner.push_back(std::move(p));
    outer.push_back(std::move(inner));
}

// vector<map<move-only>> fails to compile upon inserting an element.
void bar() {
    std::vector<std::map<std::unique_ptr<int>, std::unique_ptr<int>>> vec;
    std::map<std::unique_ptr<int>, std::unique_ptr<int>> map;
    std::unique_ptr<int> p1 = std::make_unique<int>(1);
    std::unique_ptr<int> p2 = std::make_unique<int>(2);

    map.insert(std::make_pair(std::move(p1), std::move(p2)));

    // The following line fails to compile on windows. It errors with a message about
    // the unique_ptr copy constructor being explicitly deleted. This …

这个类设计是标准的C++ 0x方式来防止复制和分配,以保护客户端代码免遭意外双重删除data吗？

struct DataHolder {
  int *data;   // dangerous resource
  DataHolder(const char* fn); // load from file or so
  DataHolder(const char* fn, size_t len); // *from answers: added*
  ~DataHolder() { delete[] data; }

  // prevent copy, to prevent double-deletion
  DataHolder(const DataHolder&) = delete;
  DataHolder& operator=(const DataHolder&) = delete;

  // enable stealing
  DataHolder(DataHolder &&other) {
    data=other.data; other.data=nullptr;
  }
  DataHolder& operator=(DataHolder &&other) {
    if(&other!=this) { data = other.data; other.data=nullptr};
    return *this;
  }
};

你注意到,我在这里定义了新的move和 …

如果我有课

class foo {
 public:
  foo() { // spend some time and do something. }
 private:
   // some data here
}

现在我有一个foo的向量,我想把这个向量放到另一个向量中

vector<foo> input; // assume it has 5 elements
vector<foo> output;

这两条线是否有任何性能差异？

output.push_back(input[0])
output.emplace_back(input[0])

问题

我有一个模板容器MyContainer<std::unique_ptr<Foo>>,它有一个std::deque<T>和一个std::vector<T>成员.

在内部方法中,如果谓词的计算结果为true send_to_purgatory_if( predicate ),我想查看所有项目m_taskdq并将项目移动到.m_taskdqm_purgatory

问题

我有两个问题,我正在努力:

• it如果我从循环内部删除m_taskdq中的项目,我的迭代器会被删除
• 我担心std::unique_ptr<>如果我分两步进行移动的状态(问题第1行和第2行 - 第2行,我认为std::unique_ptr<>指向的it是未定义的？)

我该如何修复此代码？

    template <typename T>
    class MyContainer
    {
      typedef std::function<bool(T&)>  PREDICATE;

      void send_to_purgatory_if( PREDICATE p )
      {
// bad code -------------------------------------
        for( auto it=m_taskdq.begin(); it!=m_taskdq.end(); ++it )
        {
          if ( p( *it ) )
          {
            m_purgatory.emplace_back( move( *it ));  // problem line 1
            m_taskdq.erase( it );                    // problem line 2
          } …

以下代码失败push_back并成功emplace_back:

#include <vector>
volatile int x = 0;
int main()
{        
    std::vector<int> vec;
    vec.emplace_back(x);
    vec.push_back(x); // error: no matching function for call to 'std::vector<int>::push_back(volatile int&)'
}

我理解push_backfailes因为它需要一个引用并试图volatile从该引用隐式地抛弃限定符.

但是,emplace_back 也需要引用(rvalue-references是引用).为什么区别对待？