当我执行std :: vector = std :: vector时,std :: vector的旧值会发生什么

时间:2016-01-15 05:23:21

标签: c++ c++11 vector

我有以下代码段:

std::vector<std::string> v1;
v1.push_back("Hello");
v1.push_back("World");

std::vector<std::string> v2;
v2.push_back("Good");
v2.push_back("Bye");

v1 = v2;

vector v1的旧值会发生什么。

  • 旧价值会立即被破坏吗?

  • 当向量v1摧毁时,它们将会消失。然后我怎样才能立即释放它们?

2 个答案:

答案 0 :(得分:4)

根据to the references

  

在调用之前容器中保存的任何元素都被分配或销毁。

因此,在您的示例中,原始基础std::string值将调用std::string::operator=并且它们(基础std::string本身)将不会被销毁。

如果指定的向量大于指定的向量,那么你将为向量中的元素调用析构函数,例如:

std::vector<std::string> v1;
v1.push_back("Hello");
v1.push_back("There");
v1.push_back("World");

std::vector<std::string> v2;
v2.push_back("Good");
v2.push_back("Bye");

v1 = v2;

在此示例中,std::string"Hello"的{​​{1}}值将分别分配"There""Good",而"Bye"的第3个字符串"World"将被摧毁。

请记住,虽然这仅适用 到向量中包含的元素,但请使用以下代码:

std::vector<int*> v1;
v1.push_back(new int(42));
v1.push_back(new int(24));
v1.push_back(new int(38));

std::vector<int*> v2;
v2.push_back(new int(32));
v2.push_back(new int(23));

v1 = v2;

在此代码中,发生内存泄漏,因为v1是包含指针的向量,指针本身被分配/销毁,而不是它指向的值。此示例等效于以下内容:

int* x = new int(42);
int* y = new int(24);
x = y; // memory leak here

为此,如果你想从向量中删除元素(从而调用容器中每个元素的析构函数),你可以使用clear方法,它清除向量中的所有元素,或者你也可以使用erase方法,它可以删除单个元素或多个元素。

相同的规则适用于clearerase;如果底层类型是已声明内存的指针类型,则需要确保delete向量中的元素;例如:

template < typename IteratorType >
void delete_elements(IteratorType start, IteratorType end)
{
    while (start != end) {
        delete (*start); // or delete[]
        ++start;
    }
}

std::vector<int*> v1;
v1.push_back(new int(42));
v1.push_back(new int(24));
v1.push_back(new int(38));

delete_elements(v1.begin(), v1.end());

如果你想看到这个分配在运作,你可以使用一个小测试类,如下面的代码:

#include <iostream>
#include <string>
#include <vector>

#define outi(v) std::cout << v << ", i = " << i << std::endl

class tester {
    public:
        tester() : i(42) { outi("default ctor"); }
        tester(int x) : i(x) { outi("implicit ctor"); }
        ~tester() { outi("dtor"); }
        tester(const tester& cp) : i(cp.i) { outi("copy ctor"); }
        tester& operator=(const tester& cp) {
            this->i = cp.i;
            outi("operator=");
            return *this;
        }
        // for std::cout << tester;
        friend std::ostream& operator<<(std::ostream& o, const tester& t) {
            o << t.i; return o;
        }
    private:
        int i;
};

template < typename itr >
static void printall(itr start, itr end)
{
    while (start != end) {
        std::cout << (*start) << std::endl;
        ++start;
    }
}

int main(int argc, char* argv[])
{
    std::vector<tester> v1;
    std::cout << "create v1 elements" << std::endl;
    v1.push_back(10); // implicit ctor calls
    v1.push_back(24);
    v1.push_back(33);
    printall(v1.begin(), v1.end());
    std::vector<tester> v2;
    std::cout << "create v2 elements" << std::endl;
    v2.push_back(tester(100));
    v2.push_back(tester(99));
    printall(v2.begin(), v2.end());
    std::cout << "v1 = v2" << std::endl;
    //v1.clear(); // uncomment to call dtor's
    v1 = v2;
    printall(v1.begin(), v1.end());
    return 0;
}

此程序的输出可能如下所示:

create v1 elements
implicit ctor, i = 10
copy ctor, i = 10
dtor, i = 10
implicit ctor, i = 24
copy ctor, i = 10
dtor, i = 10
copy ctor, i = 24
dtor, i = 24
implicit ctor, i = 33
copy ctor, i = 10
copy ctor, i = 24
dtor, i = 10
dtor, i = 24
copy ctor, i = 33
dtor, i = 33
10
24
33
create v2 elements
implicit ctor, i = 100
copy ctor, i = 100
dtor, i = 100
implicit ctor, i = 99
copy ctor, i = 100
dtor, i = 100
copy ctor, i = 99
dtor, i = 99
100
99
v1 = v2
operator=, i = 100
operator=, i = 99
dtor, i = 33
100
99
dtor, i = 100
dtor, i = 99
dtor, i = 100
dtor, i = 99

我说可能因为您的编译器可能会选择略微不同的构造函数/赋值顺序,但结果将是相同的。

我希望可以提供帮助。

答案 1 :(得分:2)

分配v1时会销毁v1的旧值,因为该分配会删除之前的内容。

要立即清除矢量而不指定新值,您可以使用clear方法或resize方法。