Re: null assignment in a template
comp.lang.c++.moderated is the place for C++ question in general. The
unmoderated counterpart exists, but has a much worse signal to noise
ratio.
Yes, I agree. I was unaware that I could access usenet via Google - but now
that I can, I will move over there. Thanks.
// Initialised supplies an initial value in the variable declaration
// itself NOTE: for non-scalar types (such as floating point types)
// this template won't compile due to the fact that it is illegal to
// declare a template with a non-scalar value
// Use Uninitialised instead, and declare the value in its explicit
// ctor
I'm not sure what you mean with floating point types. Indeed, template
arguments are restricted to object types, function types, integral values
and (I think) pointers. All those need to be compile-time constants.
Sorry - that's referring to another template, Uninisialized<T>, which
delcares a single (const T &) ctor to force the client to have to declare an
initial value for said variable, as oppossed to Inialised<T> which allows
for a compile-time constant initialization value to be specified in the
template parameters themselves.
template <typename T, T * zero>
struct Initialised<T*, zero>
{
Initialised() : m_value(zero) { }
template <typename U> Initialised(const U* that) : m_value(that) { }
template <typename U> T* & operator = (const U* that) { if (m_value
!=
that) m_value = that; return *this; }
T* & operator = (const int constant) { return m_value = constant; }
operator T* & () { return m_value; }
operator const T* & () const { return m_value; }
T * m_value; // the plain old data
};
This looks mightily weird. An assignment operator taking an int and one
taking a pointer? Also, what is the value of 'zero' for? Isn't it a plain
null pointer? If you want a smart pointer that must be initialised, you
could use one that doesn't have a constructor without arguments.
I only declare member operator = (const int constant) to allow for
Initialised<T*, NULL> p; p = NULL; Since NULL == 0, and not (void*)0, what
other options do I have (this is the crux of my post)?
What I really want is to allow myself to declare a plain old pointer and
guarantee that its initialized in the constructor or point of
declaration,
to make it much easier to avoid uninitialized variables issues.
Wait: either you need a plain old pointer or you get something with a
constructor. You can't modify the behaviour of a raw pointer to be
initialised!
The only fly in the ointment is that the following fails:
Initialised<Widget*, new Widget(1,2,3)> m_pWidget;
The new expression is not a compile-time constant, I wonder how this is
supposed to work.
D'oh! Right - only NULL or address of a global can be used for the second
template argument.
So the only real issue is trying to get an Initialised<T*> p to later be
assigned a NULL constant. This is what I'm trying to get to, since it is
trivial to provide for T* assignment.
I can go back to my code that uses m_pWidget and force all
null-assignments to be type-cast at the point of assignment:
m_pWidget = (Widget*)NULL;
Nah, that's way too twisted, and using C casts is a bad idea anyway.
static_cast<Widget*>(0) would be the way to go.
My point is that I don't want to have to cast it at all - I want my
Initialised<T*> wrapper to act just like a T* and allow p = NULL, exactly as
C++ would if it were unwrappered.
Not the worst idea in the universe, but I have a lot of places where I'd
like to replace the current variable / member declarations with
Initialised<Type,zero> declarations, and I don't want to have to comb
through many hundreds of lines of code to correct every NULL assignment.
How about using smart pointers? In particular this code could benefit from
the use of std::auto_ptr.
Smart pointers are great - and I use them extensively. Sometimes, fixing
code to use a smart pointer is just more work than its worth, and ownership
mechansims can be complex in legacy code, so all I really need to achieve is
a guarantee that the pointer is initialized. At least, this can be a solid
step forward in making legacy code more correct, without having to do an
extensive analysis on it. Eventually, all of the legacy code can be updated
to modern coding principles, but the reality of the situation dictates an
incrmental approach. Hence my Initialised<> templates.