Re: Workaround for partial specialization wanted
on Tue Nov 06 2007, "Matthias Hofmann" <hofmann-AT-anvil-soft.com> wrote:
"David Abrahams" <dave@boost-consulting.com> schrieb im Newsbeitrag
news:87hck4f0vd.fsf@grogan.peloton...
// Extracts the type of an object.
template <class T>
struct extract { typedef T type; };
// Extracts the type of an array.
template <class T, std::size_t N>
struct extract<T[N]> { typedef T type; };
If your target is an old version of MSVC (6 or 7), then you can use
the Boost type traits for these kinds of things. They take advantage
of a bugfeature in the compiler that allows them to do this stuff.
I just had a look at the boost website, but all I found was the
"remove_all_extents" class template, which does not exactly offer the
behaviour as my "extract" class template.
http://www.boost.org/doc/html/boost_typetraits/reference.html#boost_typetraits.remove_extent
does.
T* TrackNew( T* ptr, const char* file, int line, ...)
{
std::cout << "Tracking object allocation" << std::endl;
return ptr;
};
template <class T, std::size_t N>
T(*)[N] TrackNew( T(*ptr)[N], const char* file, int line, int)
{
std::cout << "Tracking array allocation " << std::endl;
return ptr;
}
#define NEW( T ) TrackNew( new T, __FILE__, __LINE__, 0 )
Of course, I haven't tested this, so it may be buggy. And I haven't
tested it with your compiler, which is definitely not conforming, so
I don't know how well it will handle the above. If you have trouble
you might change the return type of the 2nd overload to T*.
I'm afraid it doesn't work. My compiler
Which compiler is that?
keeps calling the object version of
the function, even when an array is allocated. The return type of the
second
overload doesn't seem to make a difference.
Oh... of course it doesn't. The result of
new T[5]
has type T*. If you really want NEW(T[5]) to return a T(*)[5] rather
than T* like new T[5], use the alternate commented-out return
statement and type below.
template <class T> inline
T* TrackNew( T* ptr, T* type, const char* file, int line, ...)
{
std::cout << "Tracking object allocation" << std::endl;
return ptr;
};
template <class T, std::size_t N> inline
T*
// T(*)[N]
TrackNew( T* ptr, const char* file, int line, T(*type)[N])
{
std::cout << "Tracking array allocation " << std::endl;
return ptr;
// return (T(*)[N])ptr;
}
template <class T> inline T* make_ptr() { return 0; }
#define NEW( T ) TrackNew( new T, __FILE__, __LINE__, make_ptr<T>() )
Well, maybe I am trying to
achieve something that's just not possible...
It might be, depending how buggy your tools are.
--
Dave Abrahams
Boost Consulting
http://www.boost-consulting.com
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]