Re: again the problem: the destructor is called twice
"David" <clamayi@gmail.com> wrote in message
news:1174662942.425828.326560@b75g2000hsg.googlegroups.com...
Hi all,
I posted my question two days ago, and tried to solve this problem.
but until now I didn't solve that. and I cut my codes so maybe this
time it is more readable.
/////////////////////////////////////////////////////
#ifndef MYCLASS_H_
#define MYCLASS_H_
#include <string>
#include <list>
//#include "name.h"
using namespace std;
class myclass
{
protected:
list<string> namelist;
// map<int,vector<name> >names;
public:
myclass();
myclass(const myclass &my);
~myclass();
// myclass& operator=(const myclass &it);
void AddName(const string &name);
void GetMyclass();
};
#endif
///////////////////////////////////////////////
myclass.cpp
#include "myclass.h"
#include <algorithm>
#include <iostream>
myclass::myclass()
{
}
myclass::myclass(const myclass &my)
{
namelist=my.namelist;
}
myclass::~myclass()
{
namelist.erase(namelist.begin(),namelist.end());
}
void myclass::AddName(const string &name)
{
list<string>::iterator ii;
ii=find(namelist.begin(),namelist.end(),name);
if(ii==namelist.end())
namelist.push_back(name);
}
void myclass::GetMyclass()
{
list<string>::iterator ii;
for(ii=namelist.begin();ii!=namelist.end();ii++)
cout<<*ii<<endl;
}
/////////////////////////////////////////////////
test.h
#ifndef TEST_H_
#define TEST_H_
#include <string>
#include <map>
#include "myclass.h"
using namespace std;
class test
{
protected:
map<string,myclass*> tests;
public:
test();
test(const test& mytest);
test& operator=(const test& ts);
~test();
void AddMyclass(const string &name,const myclass &my);
void GetTest();
};
#endif
////////////////////////////////////////////////////
test.cpp
#include "test.h"
#include <utility>
#include <iostream>
test::test()
{
}
test::test(const test& mytest)
{
tests=mytest.tests;
}
Above is your copy constructor. Yet you have a map of pointers you are not
copying correctly. Remember, your test destructor will delete the pointers,
and generally I've found that when a copy constructor is called there is a
temporary made somewhere that needs to be deleted. Pointers moving from
class to class is a bad idea where there is a delete. Generally what you
have to do is duplicate the objects the pointers are pointing to. new a new
pointer, assign the value so that when the old one gets deleted you don't
lose the data.
If I have a class that has pointers to newed objects, I always make the copy
and assignment operators private so they can't be called. Unless you work
with smart pointers you'll have issues.
Think about your line later:
ca.SetTest(tt);
ca is to have a map of the ponters, but so is tt. Yet you only newed them
once. You have 2 different objects (attempting to) point to the same
memory, but they get deleted. If you have 2 objects with pointers, for an
assignment or copy you have to copy the objects the memory is pointing to so
you have 2 seperate memories they are pointing to and their deletes work
correctly, or you have to think very very carefully about object ownership.
After cs.SetTest(tt) who do you expect to "own" the memory the pointers are
pointing to? You can't have 2 seperate instances owning the same pointers.
Unless you use smart pointers of some type.
You have a design flaw here and you are going to have to rethink your
classes.
test& test::operator =(const test &ts)
{
if(this!=&ts)
{
map<string,myclass*>::iterator ii;
for(ii=tests.begin();ii!=tests.end();++ii)
delete(ii->second);
tests.clear();
tests=ts.tests;
}
return *this;
}
test::~test()
{
map<string,myclass*>::iterator ii;
for(ii=tests.begin();ii!=tests.end();++ii)
delete(ii->second);
tests.clear();
}
void test::AddMyclass(const string &name,const myclass &my)
{
map<string,myclass*>::iterator ii;
myclass* newmyclass=NULL;
ii=tests.find(name);
if(ii==tests.end())
{
newmyclass=new myclass(my);
tests[name]=newmyclass;
}
}
void test::GetTest()
{
map<string,myclass*>::iterator ii;
for(ii=tests.begin();ii!=tests.end();ii++)
{
cout<<"the name is:"<<ii->first<<endl;
ii->second->GetMyclass();
}
}
////////////////////////////////////////////////////////////////////
call.h
#ifndef CALL_H_
#define CALL_H_
#include "test.h"
class call
{
public:
inline void SetTest(const test& ts){testagain=ts;}
protected:
test testagain;
};
#endif
///////////////////////////////////////////////////////////////////
main
#include "myclass.h"
#include "test.h"
#include "call.h"
int main()
{
test tt;
myclass my;
string ss[3]={"a","b","c"};
call ca;
for(int i=0;i<3;i++)
my.AddName(ss[i]);
my.GetMyclass();
tt.AddMyclass("my class",my);
tt.GetTest();
ca.SetTest(tt);
return 0;
}
The problem is at the line ca.SetTest(tt). Could somebody tell me how
to solve it? Thanks.