深度探索：vector中存放类与类指针的区别

[aawolf]

请大家看下边的代码：
MyTest * pMyTest,* pNewTest;
vector<MyTest> vecTest;
vector<MyTest>::iterator iter;
CString str;

for(int i=0;i<5;i++)
{
pMyTest = new MyTest();
pMyTest->a += i;
pMyTest->b += i;
pMyTest->c += i;
vecTest.push_back(*pMyTest);
// (A)
delete pMyTest;
}


for(iter = vecTest.begin(); iter!=vecTest.end();iter++)
{
pNewTest = &(*iter);
if(pNewTest->a == 4)
{
str.Format("a:%d;b:%d;c:%d",pNewTest->a,pNewTest->b,pNewTest->c);
m_list.AddString(str);
}
}

for(iter = vecTest.begin(); iter!=vecTest.end();iter++)
{
pNewTest = &(*iter);
//vecTest.erase(iter);
delete pNewTest; //这里出错
}

如果我将vector<MyTest>换成vector<MyTest*>则可以正常删除，所以我想知道vector<MyTest>和vector<MyTest*>的区别。如果是vector<MyTest>，是不是在vector内部创建了一个MyTest的对象，而无须手动delete?我在（A）处删除了new出来的对象，下面的操作仍然可以正常进行。

我的疑问是：vector<MyTest>中的对象是不是不需要手工删除？而由vector自己控制？
谢谢大家。

[darcymei]

vector<MyTest>，是不是在vector内部创建了一个MyTest的对象!
是，pushback时直接调用MyTest的拷贝构造函数，如无，bit copy.
erase时自动释放,调用析构函数。
以上楼主自己写个类，在构造函数，析构函数中加几个标记，很容易看到:0
至于
for(iter = vecTest.begin(); iter!=vecTest.end();iter++)
{
pNewTest = &(*iter);
//vecTest.erase(iter);
delete pNewTest; //这里出错
}
删除得是iter指针，当然报错喽

[ssbull]

自己在这方面也存在疑惑，在这学习学习！高兴ing

[lyr311]

高手提问，先记下一个位置。

[fullsail]

vector中存放类实际上在Vector种存放的就是对象，他的构造和析构全部是自己负责的，
可以拷贝等，比如一个vector 存放6数据,A,B,C,D,E,F,vector的结构既是
-------------
A,B,C,D,E.F
--------------
如果存放指针,vector你们存放就是6个指针，指向6个数据，生成他不会有什么构造，析构的事情。而且必须自己控制删除指针。
--
P1 ->A
P2 ->B
P3 ->C
P3 ->D
P4 ->E
P5 ->F
P6 ->G
--

[killme2008]

收藏

[mechgoukiteng]

我是买书的

[firingme]

倒！你试试把auto_ptr放到STL的容器里头？？？？

连拷贝构造都不支持，怎么可能能放进去？

还讨论是不是放进去比较好…………

[Andy84920]

我想知道vector<MyTest>和vector<MyTest*>的区别。
如果是vector<MyTest>，是不是在vector内部创建了一个MyTest的对象，


==================================================================
一个是向量中放对象,而一个是放对象的指针而矣.当然这么大的区别应该可以看到了.
如果只是声明一个vector<MyTest>对象.而并没有进行初始化,我是讲EG:
vector<MyTest> MTvec;
它是一个空vector,如果是vector<MyTest> MTvec(10);它将有十个MyTest对象.并调用
默认构造函数进行初始化.而你不能显示初始化一个向量中的每个元素.

vector它有自己的内存管理.当然只管理它内部放的东西.你放对象指针,只能说与
vecotr<int>没多大区别.它里面指针向的对象还是要你另外考虑如何处理.
不然让vector来管理它指向的对象的话,我认为乱了TAO了!

[aawolf]

谢谢大家的回复，可能对下面的话我解释的不是很清楚：

>>如果是vector<MyTest>，是不是在vector内部创建了一个MyTest的对象，

我的意思是说，vector<MyTest>在push_back的时候会创建一个MyTest的对象？我马上去试一下。

另外还有两个连带的问题：
1， pNewTest = &(*iter);
//vecTest.erase(iter);
delete pNewTest; //这里出错
我删除了迭代器的指针是不对的，那么我如何修改iter指向的MyTest对象中的值？我试图通过MyTest *指针来访问，失败了。

2，很多人提到了自动引用指针，能科普一下吗？

谢谢大家。

[aawolf]

我在MyTest的构造函数里加了一句。
MyTest::MyTest()
{
a = 1;
b = 2;
c = 3;

AfxMessageBox(_T("MyTest Create"));
}
代码1：
pMyTest = new MyTest();
vecTest.push_back(*pMyTest);
delete pMyTest;
代码2：
MyTest myTest;
vecTest.push_back(myTest);

执行两段代码，都只弹出一个MessageBox，也就是说只调用了一次构造函数。这是为什么？

[mechgoukiteng]

你需要eiffective stl这本书，强烈推荐你看看，虽然是e文的



至于引用技术指针，参考boost的实现www.boost.org


当然很多其它也有实现，问题是你考虑效率否 引用技术指针在单线程下面可能还可以


至于你的push_back为什么没有弹出AfxMessageBox是因为push_back调用的是拷贝构造函数
而不是缺省构造函数
MyTest::MyTest(const MyTest& other);

[darcymei]

欧上面说了阿
pushback时直接调用MyTest的拷贝构造函数，如无，bit copy.
顺便问一句eiffective stl哪里有down吗

[bigflyingpig]

gz

[warton]

过路,up一下!

[sofema]

学习中。。。

[killme2008]

up

[oyd]

我见过一个使用自动引用指针的例子，是这样的
list< AutoRefPtr<MyTest> > listTest;
//...
listTest.push_back(new MyTest);

自动引用指针是这么实现的
template<class T>
class AutoRefPtr{
T *m_ptr;
int m_ref;//引用计数
//...
public:
AutoRefPtr(T *p)
:m_ptr(p),m_ref(0){}
AutoRefPtr(AutoRefPtr &o);
//...
}
它析构的时候会根据引用计数来决定是否释放m_ptr。一旦用某指针来初始化自动引用指针，用户就不能再手工释放该指针了。例如不能像下面这样用：

int *p = new int;
AutoRefPtr<int> pInt(p);
delete p;//错误，pInt析构的时候会释放p的

[flc]

studying

[孩皮妞野]

MyTest * pMyTest,* pNewTest;
vector<MyTest> vecTest;
vector<MyTest>::iterator iter;
CString str;
//*************************************************************
// 下面的循环体合法但是效率极低
for(int i=0;i<5;i++)
{
pMyTest = new MyTest();
pMyTest->a += i;
pMyTest->b += i;
pMyTest->c += i;
vecTest.push_back(*pMyTest);
// (A)
delete pMyTest;
}
// 建议改为
for(int i=0;i<5;i++)
{
MyTest test;
test.a += i;
test.b += i;
test.c += i;
vecTest.push_back(test);
// (A)
}
//***************************************************************
// 下面的代码合法，效率上也没有问题，但是不够简洁
for(iter = vecTest.begin(); iter!=vecTest.end();iter++)
{
pNewTest = &(*iter);
if(pNewTest->a == 4)
{
str.Format("a:%d;b:%d;c:%d",pNewTest->a,pNewTest->b,pNewTest->c);
m_list.AddString(str);
}
}
// 改成这样更简洁，而且不会有效率上的损失
for(iter = vecTest.begin(); iter!=vecTest.end();iter++)
{
if(iter->a == 4)
{
str.Format("a:%d;b:%d;c:%d",iter->a,iter->b,iter->c);
m_list.AddString(str);
}
}

// 下面的代码非法，因为它多余了。vecTest在超出生存期析构时会保证
// 他所容纳的MyTest类型对象被正确析构，前提是MyTest有良好的定义
// 正确的做法是完全删除下面的循环体。不会有内存泄漏问题发生。
for(iter = vecTest.begin(); iter!=vecTest.end();iter++)
{
pNewTest = &(*iter);
//vecTest.erase(iter);
delete pNewTest; //这里出错
}


关于MyTest及其他其对象需要放在std::vector中类/结构的基本要求:
1. 有拷贝构造函数
2. 如果类有动态分配内存或其他资源，需要有析构函数。

[孩皮妞野]

>>我的疑问是：vector<MyTest>中的对象是不是不需要手工删除？而由vector自己控制？
谢谢大家。

不需要。vector会自己控制。

但是有一种情况要注意:

示例:
struct VeryBigObject{
int key;
char data[1024*8];

// Default CTOR
VeryBigObject(){}
// CTOR
VeryBigObject(int k, char const* d);
// Copy Ctor
VeryBigObject(VeryBigObject const& o);

// 用于排序
bool operator <(VeryBigObject const& rhs)const{
return key<rhs.key;
}
};

现在我想把大约100，000个VeryBigObject对象排序后输出。因为排序时经常会交换两个对象的位置，大对象的读写必将是费时的。可以通过把保持这些对象不动而对他们的序号[或指针]按特定顺序排列来完成这一点，一个可能的设计是。

// 提供根据指针所指对象来比较的functor
struct CmpPointer{
bool operator()(VeryBigObject * const lhs, VeryBigObject *const rhs)const{
return *lhs<*rhs;
}
};

void read_sort_and_output()
{
std::vector<VeryBigObject*> vec;

// 读取
for(unsigned i=0; i<100000; ++i){
VeryBigObject * o =new VeryBigObject;
read_a_object(o);
vec.push_back(o);
}
// 排序
std::sort(vec.begin(),vec.end(),CmpPointer());

// 输出
output(vec);


// vec中存放的是普通指针，如果不先行销毁，vec析够后这些对象将成为无人
// 看管的孤儿
for(unsigned i=0; i<vec.size(); ++i)
delete vec[i];

}

当然，用C++可以有更neat的解决方法。只是举个例子表明那些情况下需要手工删除。