Re: Smart Pointer Issue
On 12 Feb., 03:18, kmakaro...@gmail.com wrote:
Hello, I have the following classes:
class ServiceBase
{
public:
ServiceBase() {}
~ServiceBase() {}
void Stop() {}
};
Are you sure you want the destructor and Stop() to be NON-virtual?
Also, you don't need to define the default constructor in this
context.
class ServiceDerivate:public ServiceBase
{
public:
ServiceDerivate() {}
~ServiceDerivate() {}
};
And I have linked smart pointer class which, does not destroy, but
calls Stop method on its destruction:
But Stop() doesn't do anything. Won't you get a memory leak?
template <class X> class ServicePtr
{
public:
explicit ServicePtr(X* p = 0) throw()
: itsPtr(p) {itsPrev = itsNext = this;}
~ServicePtr()
{release();}
ServicePtr(const ServicePtr& r) throw()
{acquire(r);}
ServicePtr& operator=(const ServicePtr& r)
{
if (this != &r) {
release();
acquire(r);
}
return *this;
}
X& operator*() const throw() {return *itsPtr;}
X* operator->() const throw() {return itsPtr;}
X* get() const throw() {return itsPtr;}
bool unique() const throw() {return itsPrev ? itsPrev==this :
true;}
private:
X* itsPtr;
mutable const ServicePtr* itsPrev;
mutable const ServicePtr* itsNext;
void acquire(const ServicePtr& r) throw()
{ // insert this to the list
itsPtr = r.itsPtr;
itsNext = r.itsNext;
itsNext->itsPrev = this;
itsPrev = &r;
r.itsNext = this;
}
void release()
{ // erase this from the list, delete if unique
if (unique())
itsPtr->Stop();
else {
itsPrev->itsNext = itsNext;
itsNext->itsPrev = itsPrev;
itsPrev = itsNext = 0;
}
itsPtr = 0;
}
};
This looks like shared-ownership smart pointer implemented with a
doubly linked circular list. To release the object you simply call Stop
() which doesn't do anything. Why don't you just use one of the more
popular smart pointer classes?
Since ServiceBase and ServiceDerivated have to be dynamic castable i
wish I could use a pool of ServiceBase classes, and upon request to
spawn new ServicePtr holding dynamic_cast to ServiceBase. Sipmle
example:
"holding dynamic_cast"? What do you mean?
int main()
{
ServicePtr<ServiceBase> sbase;
ServicePtr<ServiceDerivate> sderivate;
sderivate=sbase;
return 0;
}
which, produces:
"no matching function for call to
'ServicePtr<ServiceDerivate>::operator=(ServicePtr<ServiceBase>&)'
note: candidates are: ServicePtr<X>& ServicePtr<X>::operator=(const
ServicePtr<X>&) [with X = ServiceDerivate]
If you want to support this (like most other smart pointer
implementations do) you need a templated-constructor and assignment
which converts the pointer type of a ServicePtr<Y> to X. You also
might need to declare that a ServicePtr<Y> is a friend of
ServicePtr<X> for X!=Y.
Can anybody help with this. Probably I am missing something.
* Think about making base class member functions pure-virtual
* Try existing smart pointers. They are already very flexible,
tested and usually support custom deleters (that could call
your Stop() function)
Cheers!
SG
--
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]