Re: [boost] shared_ptr question

22 Jun 2005

      From: H <h.v.niekerk@hccnet.nl>
...
...
Let's see if I can recast your problem to something a little
simpler to discuss:
void function2(some_type data) // stores stuff in caller's object
   {
      read_something_from_somewhere(data);
   }
void function1(some_type data) // stores stuff in caller's object
   {
      function2(data);
   }
void function3(some_type data)
   {
      // do something useful with data
   }
int main()
   {
      some_type data; // some pointer type
      function1(data); // stores stuff in data
      function3(data);
   }
Is that a good approximation of what you want?
Yes, that looks like it.
...
If so, some_type should be boost::shared_ptr<something> and the
rest should just work.  Of course, you can avoid using
boost::shared_ptr if function1() and function2() take non-const
references to some_type:
void function2(some_type & data) // stores stuff in caller's object
   {
      read_something_from_somewhere(data);
   }
void function1(some_type & data) // stores stuff in caller's object
   {
      function2(data);
   }
void function3(some_type const & data)
   {
      // do something useful with data
   }
int main()
   {
      some_type data; // not a pointer type
      function1(data); // stores stuff in data
      function3(data);
   }
OK. The original way was:
auto_ptr<FtInterface> fti (ftGetIfFromFactory(device, connection));
With shared_ptr would it become like this:
void function2(boost::shared_ptr fti (ftGetIfFromFactory(device, 	 
connection))
{
  ...
  fti->writeAndReadAllData(out,inp);
}
Absolutely not.  I'm not sure where you got the idea that you
should somehow get the object in the formal parameter list, but
that's for the object passed from the caller.
...
void function1(boost::shared_ptr fti (ftGetIfFromFactory(device, 	 
connection))
{
  function2(data);
}
int main()
{
  boost::shared_ptr<FtInterface> fti (ftGetIfFromFactory(device, 	 
connection));
  function1(fti (ftGetIfFromFactory(device, 		connection));
}
That should be something like this:

   void function1(boost::shared_ptr<FtInterface> fti)
   {
      function2(fti);
   }

   int main()
   {
      boost::shared_ptr<FtInterface> fti(ftGetIfFromFactory(...));
      function1(fti);
   }

Do you see that "boost::shared_ptr<FtInterface>" appears
everwhere I wrote "some_type" previously in this version and not
in yours?
...
What would be the benefit of using non-const references?
I told you that already.  You don't need pointers (since you're
using a factory function to create the instance, you'll need one
pointer, but the other uses don't have to be pointers).

   void function1(FtInterface & fti)
   {
      function2(fti);
   }

   int main()
   {
      std::auto_ptr<FtInterface> fti(ftGetIfFromFactor(...));
      function1(*fti);
   }

The bottom line is that your problems stem not from
boost::shared_ptr usage but from fundamental misunderstandings of
how C++ works.  The Boost Users List or comp.lang.c++.moderated
are better places to handle such questions.  It also appears that
you need to find a good tutorial on C++ to help you understand
things better.

-- 
Rob Stewart                           stewart@sig.com
Software Engineer                     http://www.sig.com
Susquehanna International Group, LLP  using std::disclaimer;