"Jeff Schwab" <jeff@schwabcenter.com> schrieb im Newsbeitrag
news:zq6dnZqTEfaeYyDanZ2dnUVZ_gednZ2d@comcast.com...
Would you consider something like this?
template<typename T>
T* New() { return new T; }
template<typename T, typename U>
T* New(U const& u) { return new T(u); }
template<typename T, typename U, typename V>
T* New(U const& u, V const& v) { return new T(u, v); }
// ... Up to some large number of arguments.
struct X {
X() { }
X(int) { }
X(int, double) { }
};
int main() {
X* p1 = New<X>();
X* p2 = New<X>(2);
X* p3 = New<X>(2, 3.0);
// ...
return 0;
}
Not a bad idea. Unfortunately, I had to give up on my memory tracker
because
I ran into a problem with the array form of the new operator. It has to do
with the requirement of a constant expression for array bounds:
#include <cstddef>
// 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; };
template <class T>
struct TrackNewImpl
{
static T* TrackNew( T* ptr )
{
// Do memory tracking for objects.
return ptr;
}
};
template <class T, std::size_t N>
struct TrackNewImpl<T[N]>
{
static T* TrackNew( T* ptr )
{
// Do memory tracking for arrays.
return ptr;
}
};
template <class T> typename extract<T>::type*
TrackNew( typename extract<T>::type* ptr )
{
return TrackNewImpl<T>::TrackNew( ptr );
}
#define NEW( T ) TrackNew<T>( new T )
int* f( std::size_t size )
{
// Error: Constant expression
// required for array bounds.
return NEW( int[size] );
}
int main()
{
int* p = f( 32 );
return 0;
}
Guess there's no solution for this?
type, so you can't parameterize TrackNew with it. It makes sense, since
isn't known until run-time. I think I know how to do this in a way
[ comp.lang.c++.moderated. First time posters: Do this! ]