Hi,
The code below produces an access violation error, complaining that an object
is destroyed twice.
I don't understand why this happens. Any help would be appreciated.
--------main.cpp---------------------------------------------------------------------------
#include "AbstractActivator.h"
// 3 classes involved:
// TextDisplayer: Base class for a hierarchy of functors that
// display a string in a certain way.
//
// Activator: Base class for a hierarchy.
//
// ActivatorFactory: Base class of a hierarchy of functors
// taht return a pointer to a std::list<Activator>
//
int main()
{
// If I don't create any intances of
// TextDisplayer, I don't get any errors
TextDisplayer show;
// ActivatorFactory is a functor that returns
// a pointer to an stl::list<Activator>
// Each Activator instance contains a pointer
// to a TextDisplayer instance. This internal instance
// is deleted in the Activator destructor.
ActivatorFactory fact;
// Activartors is a typedef for stl::list<Activator>
Activators * acts = fact();
Activators::iterator i;
// Call the activate method of all activators
for(i = acts->begin(); i != acts->end(); ++i)
{
(*i).activate();
}
// Delete the dynamically created list<Activators>
// This is were I get into trouble. This calls
// the destructor of Activator, that tries to delete
// the internal TextDisplayer. That line creates an
// error, complaining that that memory area has already
// been deleted.
delete acts;
return 1;
}
----------------end main.cpp---------------------------------------
----------abstractactivators.cpp-----------------------------------
#include <string>
#include <list>
#include "AbstractActivator.h"
// TextDisplayers
void DialogDisplayer::operator()(const std::string & aMessage)
{
//::ShowMessage(AnsiString(aMessage.c_str()));
}
// Activators
bool Activator::activate()
{
//Método base solo usado para debug
//Los específicos deben de tener en cuenta los
// posibles errores.
return true;
}
Activator::Activator(TextDisplayer * aDisplayer)
:theDisplayer(aDisplayer)
{
//do nothing
}
Activator::~Activator()
{
delete theDisplayer;
}
// Factory
Activators * ActivatorFactory::operator()(const ActivatorType aType)
{
Activators * lst = new Activators;
Activator act(new TextDisplayer);
lst->push_back(act);
return lst;
}
---------end activators.cpp-----------------------------------------------
--------activators.h-----------------------------------------
#ifndef ABSTRACT_ACTIVATOR_FLAG
#define ABSTRACT_ACTIVATOR_FLAG
#include <string>
#include <list>
class TextDisplayer
{
public:
TextDisplayer(){};
virtual ~TextDisplayer() {};
virtual void operator() (const std::string & aMessage) {};
};
class DialogDisplayer
:
TextDisplayer
{
public:
DialogDisplayer():TextDisplayer(){};
virtual ~DialogDisplayer() {};
virtual void operator() (const std::string & aMessage);
};
class Activator
{
public:
Activator(TextDisplayer * aDisplayer);
virtual ~Activator();
virtual bool activate();
private:
TextDisplayer* theDisplayer;
};
enum ActivatorType
{
NullActivator
};
typedef std::list<Activator> Activators;
class ActivatorFactory
{
public:
virtual Activators * operator()(const ActivatorType aType = NullActivator);
};
#endif //ABSTRACT_ACTIVATOR_FLAG
----------end-------------------------------------------