Velocity Reviews - Computer Hardware Reviews

Velocity Reviews > Newsgroups > Programming > C++ > Threaded SmartPtr questions

Reply
Thread Tools

Threaded SmartPtr questions

 
 
dbtouch
Guest
Posts: n/a
 
      05-06-2009
Dear C++ Users,

I am studying Modern C++ design and I simplified a threaded smart
pointer implementation as following code. As I execute it I found that
tsp is actually deleted twice. I am trying to see whether my approach
is correct and would like to hear your opinions.

dbtouch

#include <iostream>

class Foo {
public:
void func() {
std::cout << "Foo::func()" << std::endl;
}

Foo(const Foo& f) {
std::cout << "Foo::Foo(const Foo&)" << std::endl;
}

Foo() {
std::cout << "Foo::Foo()" << std::endl;
}

~Foo() {
std::cout << "Foo:~Foo()" << std::endl;
}
};

class Mutex {
public:
void acquire() {
std::cout << "Mutex.acquire()" << std::endl;
}
void release() {
std::cout << "Mutex.release()" << std::endl;
}
};

template <typename SharedObject, typename SyncPolicy>
class ThreadedSmartPtr {
SharedObject* m_ptr;
Mutex lock;

public:
ThreadedSmartPtr(SharedObject* ptr, SyncPolicy& lck) :
m_ptr(ptr), lock(lck) {
lock.acquire();
}

~ThreadedSmartPtr() {
lock.release();
}

SharedObject* operator -> () {
return m_ptr;
}
};

template <typename T>
class SmartPtr {
T *object;

public:
SmartPtr(T* value) : object(value) {
}

T operator->() {
return *object;
}

~SmartPtr() {
if (object)
delete object;
}
};

typedef ThreadedSmartPtr<Foo, Mutex> oldSmartPtr;

int main() {
Foo *ptr = new Foo;
Mutex m;
oldSmartPtr tsp(ptr, m);

SmartPtr<oldSmartPtr> sp(&tsp);
sp->func();
}
 
Reply With Quote
 
 
 
 
James Kanze
Guest
Posts: n/a
 
      05-07-2009
On May 6, 11:44 pm, dbtouch <(E-Mail Removed)> wrote:

> I am studying Modern C++ design


I'm not sure of your level, but from what I've seen and heard of
it, I don't think it's exactly for beginners in C++.

> and I simplified a threaded
> smart pointer implementation as following code. As I execute
> it I found that tsp is actually deleted twice. I am trying to
> see whether my approach is correct and would like to hear your
> opinions.


There are at least two serious problems with your code.

> #include <iostream>


> class Foo {
> public:
> void func() {
> std::cout << "Foo::func()" << std::endl;
> }


> Foo(const Foo& f) {
> std::cout << "Foo::Foo(const Foo&)" << std::endl;
> }


> Foo() {
> std::cout << "Foo::Foo()" << std::endl;
> }


> ~Foo() {
> std::cout << "Foo:~Foo()" << std::endl;
> }
> };


> class Mutex {


Not important in your example, but a real Mutex will have
identity. Which means that it won't support copy nor
assignment. Whatever you end up designing, you must take this
into account.

> public:
> void acquire() {
> std::cout << "Mutex.acquire()" << std::endl;
> }
> void release() {
> std::cout << "Mutex.release()" << std::endl;
> }
> };


> template <typename SharedObject, typename SyncPolicy>
> class ThreadedSmartPtr {
> SharedObject* m_ptr;
> Mutex lock;


If Mutex isn't copiable, nor is your ThreadedSmartPtr. (That
may or may not be a problem. The smart pointers I've seen which
manage locks all use reference counting to support copy.)

And of course, since the mutex is only known to the single
instance, there's no way it can protect anything not using the
particular instance.

> public:
> ThreadedSmartPtr(SharedObject* ptr, SyncPolicy& lck) :
> m_ptr(ptr), lock(lck) {
> lock.acquire();
> }


> ~ThreadedSmartPtr() {
> lock.release();
> }


> SharedObject* operator -> () {
> return m_ptr;
> }
> };


> template <typename T>
> class SmartPtr {
> T *object;


> public:
> SmartPtr(T* value) : object(value) {
> }


> T operator->() {
> return *object;
> }


> ~SmartPtr() {
> if (object)
> delete object;
> }
> };


> typedef ThreadedSmartPtr<Foo, Mutex> oldSmartPtr;


> int main() {
> Foo *ptr = new Foo;
> Mutex m;
> oldSmartPtr tsp(ptr, m);


> SmartPtr<oldSmartPtr> sp(&tsp);


And this will result in undefined behavior. As written, your
SmartPtr can only be initialized with dynamically allocated
objects.

> sp->func();


> }


--
James Kanze (GABI Software) email:(E-Mail Removed)
Conseils en informatique orientée objet/
Beratung in objektorientierter Datenverarbeitung
9 place Sémard, 78210 St.-Cyr-l'École, France, +33 (0)1 30 23 00 34
 
Reply With Quote
 
 
 
Reply

Thread Tools

Posting Rules
You may not post new threads
You may not post replies
You may not post attachments
You may not edit your posts

BB code is On
Smilies are On
[IMG] code is On
HTML code is Off
Trackbacks are On
Pingbacks are On
Refbacks are Off


Similar Threads
Thread Thread Starter Forum Replies Last Post
Re: questions regarding stack size use for multi-threaded pythonprograms Gabriel Genellina Python 0 11-13-2009 12:07 PM
Loki::SmartPtr syntax Mosfet C++ 1 04-10-2009 05:47 PM
SmartPtr Issues mosfet C++ 1 08-12-2008 12:53 PM
SmartPtr type conversion error tsar.omen@gmail.com C++ 1 12-30-2005 04:06 PM
More Threaded Cache Loading questions... Weston Weems ASP .Net 4 01-05-2005 09:07 PM



Advertisments