C++ 如何创建指向向量的指针向量

我有一个指向向量的指针：

vector<double> mv;
mv.push_back(233);
mv.push_back(234);
mv.push_back(654);
vector<double>* new_mv_pt = new vector<double> (3);
new_mv_pt = &mv;    

cout << (*new_mv_pt)[1] << endl;    

向量mv；
中压推回（233）；
中压推回（234）；
中压推回（654）；
向量*new_mv_pt=新向量（3）；
新的_mv_pt=&mv；
是的，但你需要这样做：

vector<vector<double>*> vop;

此处存在内存泄漏：

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

由于
vop
是一个
double*
s的向量，并且您正在尝试向其中插入一个
向量，因此无法工作。请参阅以了解正确的方法。
哇，在那里减速

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

你有一个向量，其中有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;

在代码中的这一点上，您必须使用
.At（）
或
操作符[]
访问
vop
，以获得
向量*
，然后使用
*
解除对其的引用，或使用
->
直接对其进行操作：

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

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

肮脏而快速的解决方案1是删除vop[1]
/
新鲜的\u 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

//我们的双向量指针向量。非所有
向量vop；
向量mv；
中压推回（233）；
中压推回（234）；
中压推回（654）；
//引用堆栈变量：不删除
向量*ptr_至_mv=&mv；
vop.推回（ptr_至mv）；
//制作mv的新副本
//将其放入std:：unique\u ptr中，
//就像一个基于堆栈的向量，
//我可以把自己清理干净
std：：唯一的新载体（mv）；
vop.push_back（fresh_ptr.get（））；
/*废话废话，工作*/
//就要退出了，得清理一下！
//删除新的\u ptr；//没必要
//删除ptr_至_mv；//没有

然后，你去，删除所有注释掉的代码，突然，你的东西就像哨子一样干净

当然，现在我要问你的最后一个问题是：
你到底在做什么，需要所有这些指向向量指针引用的指针？
如何删除这两个指针以避免内存泄漏？我尝试删除新的\u mv\u pt，但在运行时出现了某种断言错误。有什么问题？两个指针是什么意思？你是说
new\u mv\u pt
和向量中的那一个吗？当我尝试删除new\u mv\u pt而不在指针向量中时，它将不起作用，并且在运行时出现某种断言错误。最后，我想知道如何安全地删除它。首先，得到你的答案。第二，意识到这是一个可怕的想法，因为你正在消除向量为你管理内存的能力，这（至少）是在一开始使用它的一半。我只是想弄清楚为什么他在一开始就有一个指向向量的指针。这样做在概念上没有意义，尤其是在同一个函数/类中。这非常有用。你很喜欢我。非常感谢。这是一个非常简单问题的非常详细的答案。先生，你是个职业选手+1.
vector<double*> vop = new vector<double> (3);
vop.push_back(*new_mv_pt);
cout << (*vop)[1] << endl;

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;

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.

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

// 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!

// 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