Re: [Boost-users] shared_ptr help needed, please!

23 Mar 2004

      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 <boost/graph/property_iter_range.hpp>
#include <boost/graph/adjacency_list.hpp>
#include <boost/graph/graph_traits.hpp>
#include <boost/property_map.hpp>
#include <boost/smart_ptr.hpp>

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<boost::vertex_name_t, std::string> node_name_t;
 typedef boost::property<graph_node_t, boost::shared_ptr<CObject>, 
node_name_t> node_property_t;
 typedef boost::adjacency_list<listS, vecS, bidirectionalS, 
node_property_t> graph_t;   

 typedef graph_traits<graph_t>::vertex_descriptor vertexdescriptor_t;

 graph_t m_Graph;

//
private:
 inline boost::shared_ptr<CObject> getNodeProperty(const 
vertexdescriptor_t& vertex)
 {
  boost::property_map<graph_t, graph_node_t>::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<graph_t>::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<graph_t, vertex_name_t>::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