我有一个指向矢量的指针:

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;    

如何创建另一个将此指针存储到向量的向量? 我正在尝试这个......

    vector<double*> vop = new vector<double> (3);

vop.push_back(*new_mv_pt);

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

但它不起作用。 我正在尝试甚至可能吗?:

===============>>#1 票数:7

哇,慢下来!

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

您有一个包含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_vectorptr_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

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

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

===============>>#2 票数:3

是的,但你需要这样做:

vector<vector<double>*> vop;

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

你有什么:

vector<double *> vop

只是一个double指针的向量。

你也只想要这个:

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

===============>>#3 票数:2

你有一个内存泄漏:

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;

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

  ask by Road Rash translate from so

未解决问题?本站智能推荐: