possibility to forbid use of "this"?

[Ernst Murnleitner]

Dear Readers,

Is it possible to forbid conversion from this or use of this in general
except where it is explicitly wanted?

Reason:

I changed my program from using normal pointers to classes A, ...

typedef A * APtr;

to a shared pointer

typedef boost::shared_p tr<A> APtr;

Now, it crashes because of statements like this

// call
DoSomething(thi s);

.....
// implementation
void DoSomething(APt r a)
{
// do nothing with a
}

Obviously, "this" is converted to a shared ptr locally. Outside the function
DoSomething() the shared ptr is destroyed and hence it tries to delete the
class where "this" points, too. This is clearly not wanted.

Greetings,
Many thanks in advance

Ernst

[Ernst Murnleitner]

> Could you give an explicit code example of what you want to do, please

because creating childs within the ctor of a base sounds very much like
flawed design to me.

A version, but without smartpointers, is at
http://control.awite.com/awitecontro...trol-api/html/

I am currently cleaning up the source, therefore my questions. I began 2
years ago and the ioverall design didn`t need changes. However, in the
beginning I didn't use more sophisticated programming technics like design
patterns, factory classes etc.

Greetings

Ernst

[Ernst Murnleitner]

> Now if you can guarantee that all of the things held by an APtr have

actually been newed, then using a SmartPointer class that has some sort
of global way of knowing the number of references would be OK.
Yes, I only construct them on the heap. And if I only allow a factory to
create my Objects (e.g. as Mr. Carson suggested in another message thread),
I cannot accidentally define automatic variables.
Of course, you still have the problem that some places in the code may
be using an A* rather than an APtr. :-(

OK. Can I avoid this?

The factory only delivers sthared_ptr. The only possibility to use the
poiner would be to use the shared_ptr's get().

Greetings
Ernst

[tom_usenet]

On Wed, 7 Jan 2004 18:24:54 +0100, "Ernst Murnleitner"
<mu******@awite .de> wrote:

The library now contains a enable_shared_f rom_this<>() function. You might
look up http://www.boost.org/libs/smart_ptr/sp_techniques.html
I found this just before. Now I wonder if it is possible to use

shared_from_th is();

during construction of an object.

It isn't - the weak pointer is only initialized in the constructor of
the shared pointer, which is obviously run after the constructor of
your object.
I want to use it in the base class andonly store it in a std::vector. It would be used only after complete
construction but is needed during construction, as childs are constructed
from withing the constructor of the parent. The childs eventually get a
pointer to the parent for later use.

How are you creating your object? I suggest you use a factory, and
make the necessary extra calls after you've created the shared
pointer. e.g.

shared_ptr<Your Type> make()
{
shared_ptr<Your Type> ptr(new YourType);
//this was called from the YourType constructor before:
someFunc(ptr);
return ptr;
}

Tom

C++ FAQ: http://www.parashift.com/c++-faq-lite/
C FAQ: http://www.eskimo.com/~scs/C-faq/top.html

[Daniel T.]

"Ernst Murnleitner" <mu******@awite .de> wrote:

Now if you can guarantee that all of the things held by an APtr have
actually been newed, then using a SmartPointer class that has some sort
of global way of knowing the number of references would be OK.

Yes, I only construct them on the heap. And if I only allow a factory to
create my Objects (e.g. as Mr. Carson suggested in another message thread),
I cannot accidentally define automatic variables.

class A {
protected:
A();
};

class B: public A {
public:
B();
}

void foo( A* a );

int main() {
B b;
foo( &b );
}

How are you going to stop A's from being created on the stack again?

Of course, you still have the problem that some places in the code may
be using an A* rather than an APtr. :-(

OK. Can I avoid this?

The factory only delivers sthared_ptr. The only possibility to use the
poiner would be to use the shared_ptr's get().

Fine, but then you must be changing the origional code rather than
simply changing a typedef from A* to shared_ptr<A>.. .

[Ernst Murnleitner]

> >I found this just before. Now I wonder if it is possible to use

shared_from_th is();

during construction of an object.
It isn't - the weak pointer is only initialized in the constructor of
the shared pointer, which is obviously run after the constructor of
your object.

I tried: it throws an exception (and is also documented this way).

Therefore I used in the constructor of the baseclass something like this:

std::vector<sha red_ptr<Base> > Base::AllItemsV ector;

Base::Base(...)
{
shared_ptr<Base > p (this);
Base::AllItemsV ector.push_back (p);
....
shared_ptr<Base > pChild
(Factory::NewCh ild("newchildna me",shared_from _this()));
}

This way it seems to work. However, somewhere I read that shared_ptr cannot
be constructed in the constructor (but I cannot exactly remember). But this
seems to work.

Greetings

Ernst



I want to use it in the base class and

only store it in a std::vector. It would be used only after complete
construction but is needed during construction, as childs are constructed
from withing the constructor of the parent. The childs eventually get a
pointer to the parent for later use.

How are you creating your object? I suggest you use a factory, and
make the necessary extra calls after you've created the shared
pointer. e.g.

shared_ptr<Your Type> make()
{
shared_ptr<Your Type> ptr(new YourType);
//this was called from the YourType constructor before:
someFunc(ptr);
return ptr;
}

Tom

C++ FAQ: http://www.parashift.com/c++-faq-lite/
C FAQ: http://www.eskimo.com/~scs/C-faq/top.html