Re: [Boost-users] Macro to contruct/allocate a shared_ptr?

14 Jul 2006

      Thanks Roman.

so is this how i would use your implementation?

boost::shared_ptr<Test> t = newptr(1, 'a', "hello");

that is getting a lot closer to what i need. and is far better that a
MACRO. declaring the types may annoying however.

the good thing about this approach it that is will also be exception
safe: ie i dont need to declare a variable for the shared_ptr. and
will be cleaned up if g() fails

// exception safe
fn(newptr(1, 'a', "hello"), g());

On 7/14/06, Roman Perepelitsa  wrote:
...
bringiton bringiton  writes:
...
On 7/14/06, Michael Nicolella  wrote:
...
What's wrong with
boost::shared_ptr<Test> test( new Test );
boost::shared_ptr<Test> test( new Test( 100, 'a', "hello" ) );
http://boost.org/libs/smart_ptr/shared_ptr.htm
I'm not sure how NEW0 or NEW or New is better than new... Making a macro
that calls new doesn't encapsulate the call to new, it only obscures it and
makes it less flexible.
-----Original Message-----
From: bringiton bringiton [mailto:kneeride <at> gmail.com]
Sent: Thursday, July 13, 2006 6:38 PM
To: boost-users <at> lists.boost.org
Subject: [Boost-users] Macro to contruct/allocate a shared_ptr?
I'm trying to define a MACRO that creates a shared_ptr and hides memory
allocation. Here is what i have so far:
#define NEW0(T) boost::shared_ptr<T>(new T()); #define NEW1(T, p1)
boost::shared_ptr<T>(new T(p1)); #define NEW2(T, p1, p2)
boost::shared_ptr<T>(new T(p1, p2)); #define NEW3(T, p1, p2, p3)
boost::shared_ptr<T>(new T(p1, p2, p3));
---------------------------------
Example of usage for the type Test:
class Test {
public:
       Test() {;}
       Test(int p1) {;}
       Test(int p1, char p2) {;}
       Test(int p1, char p2, std::string p3) {;} };
boost::shared_ptr<Test> p0 = NEW0(Test); boost::shared_ptr<Test> p1 =
NEW1(Test, 100); boost::shared_ptr<Test> p2 = NEW2(Test, 100, 'a');
boost::shared_ptr<Test> p3 = NEW3(Test, 100, 'a', "hello");
---------------------------------
Is there a better way to do this? I would prefer to use a function instead
of a MACRO. But I don't think it is possible because it is not know how
many
...
...
paramaters are in T's constructor.
// not sure how to do this (or whether possible) // i am not sure how to
implement the variable parameters // (hense the .. in my syntax) template
<class T> boost::shared_ptr<T> New(...) {
       boost::shared_ptr<T> p(new T(...));
       return p;
}
Any ideas? I often have problems with the c++ syntax when creating my own
containers because i want to allocate T within the implementation (instead
of passing pointers and having the user manage the memory).
_______________________________________________
Boost-users mailing list
Boost-users <at> lists.boost.org
http://lists.boost.org/mailman/listinfo.cgi/boost-users
_______________________________________________
Boost-users mailing list
Boost-users <at> lists.boost.org
http://lists.boost.org/mailman/listinfo.cgi/boost-users
I just have a problem with having the user manage the memory. ie I'd
rather do the following:
shared_ptr<Test> p(1, 'a', "hello");
or:
shared_ptr<Test> p = newptr<Test>(1, 'a', "hello");
instead of:
shared_ptr<Test> p(new p(1, 'a', "hello"));
but i guess that's a limitation of the language. to get around this i
do the following:
class Test {
private:
   Test(int p1, char p2, string p3) {;}
public:
   static shared_ptr<Test> NewTest(int p1, char p2, string p3) {
      return p(new Test(p1, p2, p3);
   }
...
// memory allocation hidden
shared_ptr<Test> t = Test::NewTest(1, 'a', "hello");
but this is a hassle. esp when many constructors...
You can try this:
#include 
template <class R>
boost::shared_ptr<R> newptr()
{
       return boost::shared_ptr<R>(new R());
}
template 
boost::shared_ptr<R> newptr(T0 p0)
{
       return boost::shared_ptr<R>(new R(p0));
}
template 
boost::shared_ptr<R> newptr(T0 p0, T1 p1)
{
       return boost::shared_ptr<R>(new R(p0, p1));
}
// and so on...
Also you can generate newptr functions with the boost preprocessor library.
#include 
#define BOOST_PP_LOCAL_MACRO(N)\
template \
boost::shared_ptr<R> newptr(BOOST_PP_ENUM_BINARY_PARAMS(N, T, p))\
{\
       return boost::shared_ptr<R>(new R(BOOST_PP_ENUM_PARAMS(N, p)));\
}
#define BOOST_PP_LOCAL_LIMITS (0, 10)
#include BOOST_PP_LOCAL_ITERATE()
Now you can use newptr with by up to 10 arguments.
HTH,
Roman Perepelitsa.
_______________________________________________
Boost-users mailing list
Boost-users@lists.boost.org
http://lists.boost.org/mailman/listinfo.cgi/boost-users