如何创建一个指向矢量的指针向量
how to create a vector of pointers to a vector

哇，慢下来！

你在记忆中做了一些非常疯狂的事情，所以让我们从头开始吧。

您有一个包含3个元素的向量。 您想使用指针引用该向量。 让我们看看它的样子：

vector<double> mv;
mv.push_back(233);
mv.push_back(234);
mv.push_back(654);
// No no no no! You don't have to `new` a pointer that 
// you're going to assign to something else!
// This is called a memory leak, and it means you've just wasted (!!!)
// C++ memory! Don't do it 
// vector<double>* new_mv_pt = new vector<double> (3);
// Instead, do this:
vector<double>* ptr_to_mv = &mv; // No leak, immediately points to a vector<double> mv;

这照顾了第一位。 现在，让我们更深入地了解它。 您想要存储向量的引用向量。 好吧，这听起来很公平。 有几种方法可以解决它。 让我们回到mv和其他事情的例子：

vector<double> mv;
mv.push_back(233);
mv.push_back(234);
mv.push_back(654);
vector<double>* ptr_to_mv = &mv;
// So far so good. Now, based on your question, you want
// to have a list of these to point to. So:
vector<vector<double>*> vop;
vop.push_back( ptr_to_mv ); // All clean.

在你的代码中，你必须使用.at()或operator[]访问vop来获取vector<double>* ，然后使用*取消引用它或使用->直接处理它：

std::vector<double>* ptr_to_vector = vop[0]; // Got my pointer
std::cout << ptr_to_vector->at( 0 ) << std::endl; // Prints '233'

这打印233因为所有这些都是你引用mv 。 在另一个答案的评论中，你说当你删除这些指针时，你会得到一个断言。 这应该发生，因为你要删除两次东西！

记住mv ，你宣布一个很久以前的事？ 好吧，你没有把它变成一个动态的矢量。你没有new它，它没有指针。 所以当函数退出时，它会自动删除它 - 它将调用它的析构函数并在堆栈中死掉 。 如果你看一下ptr_to_vector或ptr_to_mv ，它们都引用了mv ，它会自行清理。

如果你在它上面调用delete，你就试图在mv上调用delete（这就是你指向的那个），你就是双重删除！

因此，当你有一个指向mv的指针时，不要删除它。 这是一个基于堆栈的变量。 它会自我清理。

还在关注？ 好的，让我们进一步了解一下：

现在，如果你需要new一个向量的原因 ，你不要用旧指针指定覆盖它（正如我之前告诉你的那样，你将留下内存）。 你创造了一个全新的新指针：

// Our vector of double vector pointers
vector<vector<double>*> vop;

vector<double> mv;
mv.push_back(233);
mv.push_back(234);
mv.push_back(654);

// References a stack variable: don't delete
vector<double>* ptr_to_mv = &mv;
vop.push_back( ptr_to_mv );

// Makes a fresh copy of mv. You must delete this
// manually
vector<double>* fresh_ptr = new vector<double>( mv );
(*fresh_ptr)[0] = 1337;
// changes only data in fresh_ptr, not `mv`
vop.push_back( fresh_ptr );

/* Blah blah blah, work */
// Functions about to exit, gotta clean up!
delete fresh_ptr;
//delete ptr_to_mv; // NO.
//delete vop[0]; // NO!
//delete vop[1]; // ... Already deleted from fresh_ptr
// ... This is going to get tedious if we don't have a fresh_ptr
// for every vector we need!

上面显示了问题：我们有两个指针，都在vop内部，其中一个需要通过调用delete来清理，另一个不需要因为它只是对mv的引用，它会自动清理！ 循环向量并删除所有内容将导致令人讨厌的断言发生。 我们如何处理它仍然得到我们需要的清理？

Dirty and Quick Solution 1只是delete vop[1] fresh_ptr delete vop[1] / fresh_ptr并完成它。 更好的解决方案是，无论何时new资源，都可以将其包装在名为std::unique_ptr奇妙事物中。 代码如下所示：

// Our vector of double vector pointers. Non-owning
vector<vector<double>*> vop;

vector<double> mv;
mv.push_back(233);
mv.push_back(234);
mv.push_back(654);

// References a stack variable: don't delete
vector<double>* ptr_to_mv = &mv;
vop.push_back( ptr_to_mv );

// Makes a fresh copy of mv
// puts it inside a std::unique_ptr,
// which, like a stack-based vector,
// can clean itself up
std::unique_ptr<vector<double>> fresh_ptr( new vector<double>( mv ) );
vop.push_back( fresh_ptr.get() );

/* Blah blah blah, work */
// Functions about to exit, gotta clean up!
//delete fresh_ptr; // Not necessary
//delete ptr_to_mv; // Nope.jpg

在那里，你去，删除所有注释掉的代码，突然间，你的东西干净如哨！

当然，现在，我遇到的最后一个问题是： 你到底在做什么，需要所有这些指针指向矢量指针的引用？

是的，但你需要这样做：

vector<vector<double>*> vop;

因为您正在寻找矢量指针列表。

你有什么：

vector<double *> vop

只是一个double指针的向量。

你也只想要这个：

vop.push_back(new_mv_pt); //  <- No asterisk (you don't want to de-reference it)

你有一个内存泄漏：

vector<double>* new_mv_pt = new vector<double> (3);
new_mv_pt = &mv;

你正在堆上创建一个vector<double> ，将它的地址存储在new_mv_pt ，然后用mv的地址覆盖该地址。 vector<double>仍然存在于堆上，但是您已经永久丢失了它的地址（因此无法delete它或使用它执行任何其他操作）。

这段代码：

vector<double*> vop = new vector<double> (3);
vop.push_back(*new_mv_pt);
cout << (*vop)[1] << endl;

不起作用，因为vop是double* s的向量，并且您试图将vector<double>插入其中。 请参阅Ben的答案 ，了解正确的方法。