Re: object used to convert a pointer to a c string
Vincent R wrote:
Vincent R a ?crit :
So here is my question asked differently :
in C++ (I insist) is it possible to write a kind of smart pointer
that when assigned from any type just copy the pointer EXCEPT when
it's a given type (for instance chat*).
something that would allow me to write :
IConvPtr iconvptr;
...
switch(ulPropType)
{
case TYPE_INT: { iconvPtr = &(lpProp->val.iValue); break; }
case TYPE_FLOAT: { iconvPtr = &(lpProp->val.fValue); break; }
case TYPE_STRING: { iconvPtr = &(lpProp->val.szValue); break; }
...
}
iconvPtr.getPtr()
Stripping out all that windows stuff certainly helped your question,
because now I can understand what you are asking about. (And it is
indeed not OS-specific.)
so now don't tell me it's windows specific, ulProptype is a unsigned
long that tell me the type of the pointed value.
So what I want to know if it's possible to have a IConvPtr object
that could be assigned any kind of pointer and that would allow to
have a custom action when assigning from a const char*.
Yes, it is possible to write such a class, but there are a few issues
you need to contend with.
The most important one is *ownership*: As your class contains a pointer
to some data, who will be responsible for cleaning up that data when you
are done with it? Does this answer change for the types that need a
custom action?
Another one is copying of the IConvPtr object. Would that be allowed or
not? If allowed, should copying create a deep copy (i.e. also copy the
data pointed to)?
Do I need to write a assignement overload for every type that can be
assigned ?
No, you can write a templated operator= for the general case and provide
specific overloads for the types that need custom treatment.
Could templated class could be of any help ?
It could, but I wouldn't bother.
Finally I did this but I find it ugly because I have to explicitly
write code for each type I am assiging...
class IConvPtr
{
public:
IConvPtr(void* pVoidVal):m_ptr(pVoidVal)
{
;
}
You might want an additional constructor
IConvPtr(wchar_t* pWstringVal)
{
// do your special thing
}
IConvPtr& IConvPtr::operator=(void* pVoidVal) {m_ptr = pVoidVal;
return *this;}
IConvPtr& IConvPtr::operator=(CEBLOB* pBlobVal) {m_ptr = pBlobVal;
return *this;}
IConvPtr& IConvPtr::operator=(USHORT* pusVal) {m_ptr = pusVal; return
*this;}
You can collapse the assignment operators above into
template <typename T>
IConvPtr& operator=(T* pVal) { m_ptr = pVal; return *this; }
IConvPtr& IConvPtr::operator=(wchar_t* pWStringVal)
{
// Do something specific
return *this;
}
operator void *()
{
return m_ptr;
}
private:
void* m_ptr;
};
Bart v Ingen Schenau
--
a.c.l.l.c-c++ FAQ: http://www.comeaucomputing.com/learn/faq
c.l.c FAQ: http://c-faq.com/
c.l.c++ FAQ: http://www.parashift.com/c++-faq-lite/