Re: Smart Pointers and Microsoft Foundation Classes

From:

"Roger Rabbit" <roger@rabbit.com>

Newsgroups:

microsoft.public.vc.mfc

Date:

Tue, 19 Feb 2008 17:13:19 -0800

Message-ID:

<8075D0D1-ACDE-41EA-8686-94FB3B6ED877@microsoft.com>

This is a multi-part message in MIME format.

------=_NextPart_000_0217_01C8731A.B94AA540
Content-Type: text/plain;
charset="iso-8859-1"
Content-Transfer-Encoding: quoted-printable

Here is my latest code snippet to act as a LockProxy for 'repairing' a =
bad design of my counted reference pointer program I wrote late last =
night . So I am considering it legacy code just to find out how abstract =
I can get C++ to go.....

#include <msclr/lock.h> // compile with /clr for the Windows calls
using namespace System;
using namespace System::Threading;
using namespace msclr;
//The proxy for fixing the legacy application code to minimize changes
template <class T>
ref class LockProxy {
public:
LockProxy(T* pObj) : pointee (pObj) { lock l(this); }
~LockProxy() { lock l(this); }
LockProxy operator->() const { return pointee; }
LockProxy operator&() const { return pointee&; }
LockProxy operator++() const {
lock l(this); // lock on an increment
return pointee++;
}
LockProxy operator--() const {
lock l(this); // lock on an decrement
return pointee--;
}
bool operator==(LockProxy(T)) const {
return this==pointee;
}
bool operator<(LockProxy(T)) const {
return this<pointee;
}
private:
T* pointee;
};

"Doug Harrison [MVP]" <dsh@mvps.org> wrote in message =
news:k28mr3he6h148ev9ogvtkcg2a7kdvafrog@4ax.com...

On Tue, 19 Feb 2008 10:19:41 -0800, "Roger Rabbit" <roger@rrabbit.com>
wrote:

Consider this, when I write win_main(...)I create a handle to my =

instance

that is running. I could use the pointer to determine if I am running =

second instance or not. I could for example see that I am already =

running,

so what not spawn a new tab in the document window.

Sure, you could write a class to manage that. I wouldn't call it a =

"smart

pointer", though, because that's really stretching the meaning of the =

term.

In C++, the term is used to describe a class that solves some of the
problems that come with raw pointers, such as the need to delete them =

some point.

For example a multi document interface text editor would create an =

abstract

Document and derive TextDocument and RichTextDocument classes. That =

seems

pretty basic, but its more tricky when a new tab surfaces. Ownership =

becomes

important which is why I started pondering smart pointers in the first =

place.

Ownership is always important. Smart pointers can help you implement =

the

ownership semantics you require.

--
Doug Harrison
Visual C++ MVP

------=_NextPart_000_0217_01C8731A.B94AA540
Content-Type: text/html;
charset="iso-8859-1"
Content-Transfer-Encoding: quoted-printable

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML><HEAD>
<META http-equiv=Content-Type content="text/html; =
charset=unicode">
<META content="MSHTML 6.00.6000.16587" name=GENERATOR></HEAD>
<BODY id=MailContainerBody
style="PADDING-RIGHT: 10px; PADDING-LEFT: 10px; PADDING-TOP: 15px"
bgColor=#ffffff leftMargin=0 topMargin=0 CanvasTabStop="true"
name="Compose message area">Here is my latest code =
snippet to act
as a LockProxy for 'repairing' a bad design of my counted reference =
pointer
program I wrote late last night . So I am considering it legacy code =
just to
find out how abstract I can get C++ to go..... #include =
<msclr/lock.h>     //
compile with /clr for the Windows calls using namespace =
System; using
namespace System::Threading; using namespace msclr; //The proxy =
for fixing
the legacy application code to minimize changes template <class
T> ref class LockProxy { public: LockProxy(T* pObj) : =
pointee (pObj)
{ lock l(this); } ~LockProxy() { lock l(this); } LockProxy =
operator->()
const { return pointee; } LockProxy operator&() const { return
pointee&; } LockProxy operator++() const { lock l(this); // =
lock on an
increment return pointee++; } LockProxy operator--() const =
{ lock
l(this); // lock on an decrement return pointee--; } bool
operator==(LockProxy(T)) const { return =
this==pointee; } bool
operator<(LockProxy(T)) const { return
this<pointee; } private: T* =
pointee; }; "Doug
Harrison [MVP]" <dsh@mvps.org> wrote in message
news:k28mr3he6h148ev9ogvtkcg2a7kdvafrog@4ax.com... > On Tue, 19 =
Feb 2008
10:19:41 -0800, "Roger Rabbit" <roger@rrabbit.com> > =
wrote: >
 >>Consider this, when I write win_main(...)I create a handle =
to my
instance >>that is running. I could use the pointer to =
determine if I
am running a >>second instance or not. I could for example see =
that I
am already running, >>so what not spawn a new tab in the =
document
window. > > Sure, you could write a class to manage that. I =

wouldn't call it a "smart > pointer", though, because that's =
really
stretching the meaning of the term. > In C++, the term is used to =
describe
a class that solves some of the > problems that come with raw =
pointers,
such as the need to delete them at > some point. > =
 >>For
example a multi document interface text editor would create an abstract
 >>Document and derive TextDocument and RichTextDocument =
classes. That
seems >>pretty basic, but its more tricky when a new tab =
surfaces.
Ownership becomes >>important which is why I started pondering =
smart
pointers in the first >>place. > > Ownership is =
always
important. Smart pointers can help you implement the > ownership =
semantics
you require. > > -- > Doug Harrison > Visual =
C++
MVP</BODY></HTML>

------=_NextPart_000_0217_01C8731A.B94AA540--