again, hi all....
After writing an example to demonstrate the problem, as per Peter's
request, I could not repro it, until I added this extra line
glutMainLoop(); before the return 0; of main.cpp. As for those how might
not know that glutMainLoop does.... Enters the GLUT event processing
loop, never to return. One would use the GLUT library when writing
OpenGL applications. If I comment out this line, then I can account for
every single class destructor call, i.e. no leaks. When it is NOT
commented, then most of the class destructor calls do not get called, or
printed (this I will verify) and therefore my guess is that there are
leaks. Anyway, since I have done the work to write the test case, I
might as well post it. This code does NOT contain the glutMainLoop() I
mentionned. I could do so if required, but Id need to also send you a
makefile.
When I figure out what is going on, I will let you know... If anyone has
any ideas, please feel free to share!
Thanks, Eric
Test code.....
/*****************************************************************************/
// main.cpp
/*****************************************************************************/
#include <iostream>
#include <string>
#include
#include
#include
#include
#include
using namespace std;
using namespace boost;
/*****************************************************************************/
//
class CObject
{
protected:
CObject(){};
protected:
virtual ~CObject(){cout << "CObject cleanup" << endl;};
public:
virtual void SetObjectName(const string& strName) = 0;
virtual const std::string GetObjectName() = 0;
};
//
class C1 : public CObject
{
public:
C1(){};
protected:
virtual ~C1(){cout << "C1 cleanup" << endl;};
public:
// Copy constructor
C1(const C1& object) : CObject(object){};
};
class C2 : public C1
{
public:
C2();
C2(const string& strName) : m_strName(strName) {};
~C2(){cout << "C2 cleanup" << endl;};
public:
// Copy constructor
C2(const C2& object) : C1(object), m_strName(object.m_strName) {};
// Data
private:
string m_strName;
public:
inline void SetObjectName(const string& strName) {m_strName = strName;};
inline const std::string GetObjectName() {return m_strName;};
};
//
struct graph_node_t
{
enum { num = 1000 };
typedef boost::vertex_property_tag kind;
};
struct Print
{
template<class T> Print& operator() (const T& t)
{
std::cout << t << endl;
return (*this);
}
};
//
class CTester
{
public:
CTester() {};
~CTester() {cout << "CTester cleanup" << endl;};
// Graph stuff
private:
typedef boost::property node_name_t;
typedef boost::property node_property_t;
typedef boost::adjacency_list graph_t;
typedef graph_traits::vertex_descriptor vertexdescriptor_t;
graph_t m_Graph;
//
private:
inline boost::shared_ptr<CObject> getNodeProperty(const
vertexdescriptor_t& vertex)
{
boost::property_map::type node_prop_map;
node_prop_map = boost::get(graph_node_t(), m_Graph);
return node_prop_map[vertex];
}
boost::shared_ptr<CObject> getNodebyName(const std::string& strName)
{
boost::shared_ptr<CObject> node_prop;
boost::graph_traits::vertex_iterator vi, vi_end;
boost::tie(vi, vi_end) = boost::vertices(m_Graph);
for(; vi != vi_end; ++vi)
{
node_prop = getNodeProperty(*vi);
if(node_prop != 0)
{
if(node_prop->GetObjectName() == strName)
break;
}
}
return node_prop;
}
//
public:
template <typename T> void addObject(const T& object)
{
// Create a vertex
boost::shared_ptr<T> spObject(new T(object));
// Add the vertex + its name to the graph
boost::add_vertex(node_property_t(spObject,
node_name_t(spObject->GetObjectName())), m_Graph);
}
template <typename T> boost::shared_ptr<T> getobject(const std::string&
strName)
{
boost::shared_ptr<CObject> abc = getNodebyName(strName);
shared_ptr<T> def = boost::dynamic_pointer_cast<T>(abc);
return def;
}
void PrintObjects()
{
graph_property_iter_range::type test =
get_property_iter_range(m_Graph, vertex_name_t());
cout << "Printing all vertices:" << endl;
std::for_each(test.first, test.second, Print());
}
};
/*****************************************************************************/
int main(int argc, char **argv)
{
CTester tester_class;
tester_class.addObject(C2("class one"));
tester_class.addObject(C2("class two"));
boost::shared_ptr<C2> abc = tester_class.getobject<C2>("class one");
cout << abc->GetObjectName() << endl;
return 0;
}
/*****************************************************************************/
Peter Dimov wrote:
Eric Damphousse wrote:
hi all,
quick question concerning shared_ptr... not sure if things get
deleted (destroyed) properly and its freaking me out. I hope this is
not too long [...]
Please post a complete example that demonstrates the problem.
_______________________________________________
Boost-users mailing list
Boost-users@lists.boost.org
http://lists.boost.org/mailman/listinfo.cgi/boost-users
