boost smart_ptr and WIN32 PostMessage

[figsys]

I am looking for a simple wrapper or mechanism to send a boost
smart_ptr using WIN32 PostMessage (or PosthreadMessage). The smart_ptr
should be incremented when sent and decremented when received (or
derefenced).

WIN32 is not "C++ enabled" and thus does not allow to cast a smart_ptr
into an LPARAM or WPARAM.

Something like

DWORD nID;
HANDLE m_hBxTxThread = CreateThread (NULL, 0, MyThread, NULL, 0, &nID);

boost::smart_ptr<MyObject> pSmart( new MyObject);
pSmart->Set(100);

PostThreadMessage( nID, 0, 0, (LPARAM) pSmart );

does not work - can convert smart_ptr to LPARAM. This works but defeats
the point since reference is not incremented:

PostThreadMessage( nID, 0, 0, (LPARAM) &pSmart )

Thanks!

 

[Phlip]

HANDLE m_hBxTxThread = CreateThread (NULL, 0, MyThread, NULL, 0, &nID);

Firstly, you should find any means necessary to avoid threads. Your
application should be event driven, so its working thread can time-slice
events.

Almost none of the tutorials on threads adequately describe why to
use them. They typically say, "If you have a function that runs too long,
you can just use threads!" A function could run too long for many reasons,
including processing a long list, or blocking on a semaphore. The former
should be broken up into a time-sliced routine, so the GUI thread can
strobe it with a timer. The latter should be multiplexed, so GUI events
dispatch synchronously with event threads.

All those techniques lead to better designs. These, in turn, are trivially
easy to multi-thread if you then determine you have a real need.

boost::smart_ptr<MyObject> pSmart( new MyObject); pSmart->Set(100);

PostThreadMessage( nID, 0, 0, (LPARAM) &pSmart );

Use SendMessage(...pSmart.get()), and fully use the target object before
the event returns.

Or pass a semaphore and block until the receiver clears it. The receiver
will reconstitute the smart pointer and then copy it into another smart
pointer.

And that technique depends on thread-ready smart pointers. You might want
to back off and invent a new smart pointer (they are very easy) that is
Win32-thread aware. A boost mailing list might be able to instruct you to
re-use their smart pointers with policy objects that enable Win32.

From here, your next question should go to a newsgroup with win32 and
programming in its name. This newsgroup is only qualified to discuss the
raw C++ language itself. Boost smart pointers barely qualify, and threads
do not.

 

[Your Uncle]

Firstly, you should find any means necessary to avoid threads. Your
application should be event driven, so its working thread can time-slice
events.

Almost none of the tutorials on threads adequately describe why to
use them. They typically say, "If you have a function that runs too long,
you can just use threads!" A function could run too long for many reasons,
including processing a long list, or blocking on a semaphore. The former
should be broken up into a time-sliced routine, so the GUI thread can
strobe it with a timer. The latter should be multiplexed, so GUI events
dispatch synchronously with event threads.

All those techniques lead to better designs. These, in turn, are trivially
easy to multi-thread if you then determine you have a real need.

That's as good a hundred word appaisal on threads as I've ever laid eyes on.

Use SendMessage(...pSmart.get()), and fully use the target object before
the event returns.

Or pass a semaphore and block until the receiver clears it. The receiver
will reconstitute the smart pointer and then copy it into another smart
pointer.

And that technique depends on thread-ready smart pointers. You might want
to back off and invent a new smart pointer (they are very easy) that is
Win32-thread aware. A boost mailing list might be able to instruct you to
re-use their smart pointers with policy objects that enable Win32.

From here, your next question should go to a newsgroup with win32 and
programming in its name. This newsgroup is only qualified to discuss the
raw C++ language itself. Boost smart pointers barely qualify, and threads
do not.

That certainly sounds like the right answer for the topical part. Boost has
progressed farther than I had anticpated. fu

 

[Peter]

I am looking for a simple wrapper or mechanism to send a boost
smart_ptr using WIN32 PostMessage (or PosthreadMessage). The smart_ptr
should be incremented when sent and decremented when received (or
derefenced).

WIN32 is not "C++ enabled" and thus does not allow to cast a smart_ptr
into an LPARAM or WPARAM.

Something like

DWORD nID;
HANDLE m_hBxTxThread = CreateThread (NULL, 0, MyThread, NULL, 0, &nID);

you may want to use _beginthreadex() instead -- since you're very
likely using the C++ library and CreateThread() does not initialize the
new thread for using the C++ library.

Since _beginthreadex() may fail you may want to wrap it into a C++
wrapper,
throwing an exception in case of it fails.

boost::smart_ptr<MyObject> pSmart( new MyObject);

You MyObject should have a private constructor and a static method

pSmart->Set(100);

I take operator overloading for the -> operator as code obfuscation.
This confuses the hell out of somebody reading your code.
Also pSmart is not a pointer but an object and your naming should
reflect this
(this is just my personal opinion).
What is the problem with writing:

sSmart.get()->Set(100);

PostThreadMessage( nID, 0, 0, (LPARAM) pSmart );

I guess the point is to pass the object pointed to by the smart pointer
to the thread.
I would pass the contained pointer to MyObject to PostThreadMessage()
after incrementing the reference count by one.
The thread can then decrement the reference count by one after
receiving the message.