c++ - vector 调整大小行为复制和赋值

Question

我有以下代码。并尝试了解插入 vector 的工作原理。

// create vector of 10 widget objects.
    vector<Widget> v(10);
    // create widget objects for insertion to vector.
    Widget w1(4);
    Widget w2(5);
    Widget w3(6);

    Widget data[] = { w1, w2, w3 };

    // create insert location for beginning.
    vector<Widget>::const_iterator insertLoc(v.begin());

    for (int i = 0; i < 3; ++i) {
      // Returns an iterator which points to the newly inserted element
      // vector insert if first argument is q, then adds element before the element referenced by the iterator 'q'.
      std::cout << "--- loop before insert *** size: " << v.size() << " capacity: " << v.capacity() << " insertloc val:  " << *insertLoc <<  std::endl;
      insertLoc = v.insert(insertLoc, data[i]);
      insertLoc++;
    }

这里我有以下输出

 --- loop before insert *** size: 10 capacity: 10 insertloc val:  Widget value is  0
Copy constructor called 4
Copy constructor called 0
Copy constructor called 0
Copy constructor called 0
Copy constructor called 0
Copy constructor called 0
Copy constructor called 0
Copy constructor called 0
Copy constructor called 0
Copy constructor called 0
Copy constructor called 0

Widget destructor is called 0
Widget destructor is called 0
Widget destructor is called 0
Widget destructor is called 0
Widget destructor is called 0
Widget destructor is called 0
Widget destructor is called 0
Widget destructor is called 0
Widget destructor is called 0
Widget destructor is called 0

我可以理解上面的代码，因为这里我们正在重新分配 vector 空间，并且使用复制构造函数复制 vector 的元素，并调用旧元素的析构函数。

--- loop before insert *** size: 11 capacity: 15 insertloc val:  Widget value is  0
Copy constructor called 5
Copy constructor called 0
operator = called  0
operator = called  0
operator = called  0
operator = called  0
operator = called  0
operator = called  0
operator = called  0
operator = called  0
operator = called  0
operator = called  5
Widget destructor is called 5

这是我无法理解的问题。如何在上面的输出中看到下面的输出

Copy constructor called 5
Copy constructor called 0

另一个问题是为什么要调用小部件析构函数。

Widget destructor is called 5

感谢您的宝贵时间和帮助。

我在下面提供Widget代码以供引用

ifndef __WIDGET__
#define __WIDGET__

#include <iostream>

class Widget {
public:
    Widget(int i = 0) : val(i), valid(true) { std::cout << "Constructor called val  " << val << std::endl; }
    virtual void draw(double ScaleFactor = 1) const;
    int getVal() const { return val; }

    int redraw() const {/* std::cout << "Drawing Widget(" << val << ")\n";  */ return 0; }
    bool isCertified() /*const*/ { return val % 2 == 0;}    // whether the Widget is certified
    friend std::ostream &operator<<(std::ostream &, const Widget &);
    friend std::istream &operator>>(std::istream &, Widget &);
    friend bool operator!=(const Widget &, const Widget &);
    friend bool operator==(const Widget &, const Widget &);
    friend bool operator<(const Widget &, const Widget &);
    int test();             // perform a self-test; mark *this

    // Venkata added.
    // Copy constructor
    Widget(const Widget &copy) :
        val(copy.val), valid(copy.valid)
    {
        std::cout << "Copy constructor called " << val << "\n";  // just to prove it works
    }

    ~Widget() {
        std::cout << "Widget destructor is called " << val << "\n";  // just to prove it works
    }

    // Overloaded assignment
    Widget& operator= (const Widget &w);

protected:
    int val;
private:
    bool valid;
};

void Widget::draw(double ScaleFactor) const
{
    std::cout << "Drawing widget (val = " << val << ") using ScaleFactor " <<
            ScaleFactor << "..." << std::endl; 
}

// A simplistic implementation of operator= (see better implementation below)
Widget& Widget::operator= (const Widget &w)
{
    // do the copy
    val = w.val;
    valid = w.valid;
    std::cout << "operator = called  "<< val << "\n"; // just to prove it works 
    // return the existing object so we can chain this operator
    return *this;
}


inline bool operator!=(const Widget &w1, const Widget &w2)
{
    std::cout << "Widget operator != called " << std::endl;
    return (w1.val != w2.val);
}

inline bool operator==(const Widget &w1, const Widget &w2)
{
    std::cout << "Widget operator == called " << std::endl;
    return (w1.val == w2.val);
}

inline bool operator<(const Widget &w1, const Widget &w2)
{
    std::cout << "Widget operator < called " << std::endl;
    return (w1.val < w2.val);
}


inline std::ostream &operator<<(std::ostream &o, const Widget &w)
{
    return o << "Widget value is  " << w.val;
}

inline std::istream &operator>>(std::istream &o, Widget &w)
{
    return o >> w.val;
}

inline int Widget::test()               // perform a self-test; mark *this
{
    return valid = (val % 2 == 0);              // only "valid" if it is even
}

// End Widget.h
#endif

Answer 1

I can understand above code as here we are re-allocating vector space

std::vector 不会在每次插入时重新分配，它会分配比要求更多的部分，以实现最后重复插入的平均 O(n) 的要求。

capacity() 告诉您它分配了多少，并且通常会大于 size()。

当它调整大小时，您会看到每个 Widget 都使用它的复制构造函数，因为它构造了一个新的内部数组。

--- loop before insert *** size: 11 capacity: 15 insertloc val:  Widget value is  0
Copy constructor called 5
Copy constructor called 0
operator = called  0
operator = called  0
operator = called  0
operator = called  0
operator = called  0
operator = called  0
operator = called  0
operator = called  0
operator = called  0
operator = called  5
Widget destructor is called 5

所以当 data[1] (5) 被插入时看起来是这样的。

之前的插入是在 begin() 处，通过 insert 返回一个新的迭代器到相同的位置，然后你将它递增 1，所以 insertLoc 将引用 v[1]。

所以 Widget 值 4 已经在正确的位置，因此不需要移动。但是 v[1] 已经被某些东西占用了。看起来 vector 已经分配了足够的空间，因此没有重新分配。

“Copy constructor called 5”用于一些临时对象。

“Copy constructor called 0”是将数组扩大一，通过向前复制构造最后一个元素。内部数组一定已经足够大，所以没有发生重新分配(有点像 v[v.size()] = v.back();)。

"operator = called 0"这些就是它然后将其余元素向前移动 1，目标对象已经构造，因此使用赋值。 v[i] = v[i - 1]。

“operator = called 5”然后随着一切向前移动，它会将它创建的临时对象分配到所需的 v[1] 位置。

“Widget 析构函数被称为 5”并析构临时对象。