Re: null assignment in a template
Steve Wolf wrote:
Please excuse me if there is a better place for this post. I could not
find one in MS's communities. My question is about template programming
in C++, not really about STL.
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.
// 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.
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.
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.
m_pWidget = NULL;
Since this line evaluates to Initialised::operator = (int) { m_value =
int; }
There is no conversion from int to Widget*!
Replace that operator overload with a pointer version, then it will
automatically invoke the correct conversion.
Now, I can certainly do the obnoxious thing and cast int to Widget* in
operator=(int), and then leave it up to the user to ensure that any int
assignments are always the value NULL, but that's just sloppy and asking
for trouble.
Yes, casts are generally wrong or a sign of broken code.
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.
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.
What I Really Want(tm) is to be able to have m_pWidget = NULL evaluate to
a valid expression, and m_pWidget =
<any-other-integer-or-other-non-convertible-type> to error with "no
conversion from <type> to Widget*".
Provide an overload for Widget*? You could also #include <boost/none.hpp>
and then provide an overload for boost::none_t which just sets the pointer
to zero. Or, how about simply using a reset() function? But then, you'd be
in the area of smart pointers again, and could as well use one of them.
PS: Its Initialised instead of Initialized due to the fact that I already
have an Initialized template for POD structs, and I wanted one for simple
singular data types as well.
....and it's proper English. However, using this name twice with different
spellings would guarantee you a spanking with a wet towel if you were in my
team!
Uli