哇,慢下来!
你在记忆中做了一些非常疯狂的事情,所以让我们从头开始吧。
您有一个包含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
在那里,你去,删除所有注释掉的代码,突然间,你的东西干净如哨!
当然,现在,我遇到的最后一个问题是: 你到底在做什么,需要所有这些指针指向矢量指针的引用?