Hi
Currently I am working on upgrading our system to work with MsDev2010 - our
system uses GCC_XML to parse our project in order to get information about the
produced DLL.
That being said I found a few newer versions of GCC_XML some of which had
implemented some STL types, for example vector: in the include for "Vc8ex"
there is a file that contains the definition of the vector class. For the other
classed I created my own definitions however I am concerned that my output will
not work as expected see my definition for shared pointer:
template<class _Ty> struct shared_ptr {};
GCC_XML has no problem parsing this and my code seems to function correctly.
However what about the class size? Will the compiler adjust for the actual size
of the class or is there a possibility that my objects body will overlap in the
heap?
Chris Lamothe
P.S. Why is my stub so much simpler than auto_ptr? - See below, looks like the
whole H file.
template<class _Ty> class auto_ptr { // wrap an object
pointer to ensure destructionpublic: typedef _Ty element_type;
explicit auto_ptr(_Ty *_Ptr = 0) _THROW0() : _Myptr(_Ptr)
{ // construct from object pointer }
auto_ptr(auto_ptr<_Ty>& _Right) _THROW0() :
_Myptr(_Right.release()) { // construct by assuming pointer
from _Right auto_ptr }
auto_ptr(auto_ptr_ref<_Ty> _Right) _THROW0() { //
construct by assuming pointer from _Right auto_ptr_ref _Ty
**_Pptr = (_Ty **)_Right._Ref; _Ty *_Ptr = *_Pptr;
*_Pptr = 0; // release old _Myptr = _Ptr; // reset this
}
template<class _Other> operator auto_ptr<_Other>() _THROW0()
{ // convert to compatible auto_ptr return
(auto_ptr<_Other>(*this)); }
template<class _Other> operator auto_ptr_ref<_Other>()
_THROW0() { // convert to compatible auto_ptr_ref
_Other *_Testptr = (_Ty *)_Myptr; // test implicit conversion
auto_ptr_ref<_Other> _Ans(&_Myptr); return (_Testptr != 0 ? _Ans :
_Ans); }
template<class _Other> auto_ptr<_Ty>&
operator=(auto_ptr<_Other>& _Right) _THROW0() { // assign
compatible _Right (assume pointer) reset(_Right.release());
return (*this); }
template<class _Other> auto_ptr(auto_ptr<_Other>& _Right)
_THROW0() : _Myptr(_Right.release()) { //
construct by assuming pointer from _Right }
auto_ptr<_Ty>& operator=(auto_ptr<_Ty>& _Right) _THROW0()
{ // assign compatible _Right (assume pointer)
reset(_Right.release()); return (*this); }
auto_ptr<_Ty>& operator=(auto_ptr_ref<_Ty> _Right) _THROW0()
{ // assign compatible _Right._Ref (assume pointer) _Ty
**_Pptr = (_Ty **)_Right._Ref; _Ty *_Ptr = *_Pptr;
*_Pptr = 0; // release old reset(_Ptr); // set new
return (*this); }
~auto_ptr() { // destroy the object delete
(_Ty *)_Myptr; }
_Ty& operator*() const _THROW0() { // return
designated value
#if _HAS_ITERATOR_DEBUGGING if (_Myptr == 0)
_DEBUG_ERROR("auto_ptr not dereferencable"); #endif /* _HAS_ITERATOR_DEBUGGING
*/
__analysis_assume(_Myptr);
return (*(_Ty *)_Myptr); }
_Ty *operator->() const _THROW0() { // return
pointer to class object return (&**this); }
_Ty *get() const _THROW0() { // return wrapped
pointer return ((_Ty *)_Myptr); }
_Ty *release() _THROW0() { // return wrapped
pointer and give up ownership _Ty *_Tmp = (_Ty *)_Myptr;
_Myptr = 0; return (_Tmp); }
void reset(_Ty* _Ptr = 0) { // destroy designated
object and store new pointer if (_Ptr != _Myptr)
delete (_Ty *)_Myptr; _Myptr = _Ptr; }
private: const _Ty *_Myptr; // the wrapped object pointer };
_______________________________________________
Powered by www.kitware.com
Visit other Kitware open-source projects at
http://www.kitware.com/opensource/opensource.html
Follow this link to subscribe/unsubscribe:
http://www.gccxml.org/mailman/listinfo/gccxml
