 |
Using Typedefs To Write Maintainable Code
Submitted by |
Using typedefs to write maintainable code (when using templates and the STL)
Writing code isn't everything. Being able to maintain your code is also
very important, (especially in a team environment where others may have to
maintain your code, and you may have to maintain code written by others).
The key to being able to maintain your code, is writing maintainable code,
this tip should help you do that.
When you instantiate a template you create a new type. When you create a
type it has a name, and that name is part of its interface. In fact, when
you refer to a type, you often do so through its name, which makes the name
a very important part of the interface.
We all know that separation of interface and implementation is very
important, this use of abstraction is one of the fundamental tenants of
object orientated programming, and lets us write flexible, orthogonal
systems. Yet the name given to this type by the compiler describes its
implementation, not its type.
Lets have look at the new type we create when we instantiated a template.
We will assume we are creating, say, a list of names, for identifying
players:
//...
std::vector<std::string nameList;
//... |
What we have done here is create a type that is intended to be a Name List,
but when we use it in our code we refer to it as a Vector Of Strings. Not
necessarily what we wanted. At a later date you may discover that the usage
pattern of the Name List is not quite what you expected, and your getting a
performance hit, you may want to change how you implemented it.
Unfortunately you code is already littered with code that looks like this:
//...
for (vector<string::iterator i = nameList.begin(); i != nameList.end()){
//...
}
//... |
And that's not all. You've used plenty of vectors of strings in other
places in your code, and for other reasons. Perhaps you've got mixed
namespace use (sometimes std is manually qualified, sometimes the names
spaces has been 'opened'). Even if you do a search-and-replace, every line
of code you touch should be re-tested.
But this problem is easily solved. Instead you create descriptive type
names using the typedef keyword:
//...
typedef std::vector<std::string NameList;
NameList nameList;
//... |
Now where you use the container, your code will look like this:
//...
for (NameList::iterator i = nameList.begin(); i != nameList.end()){
//...
}
//... |
But that's not all - we can take this further. Perhaps std::string wasn't
the best implementation to use for names. Names after all, don't change
very often. Perhaps you should have rolled your own class for that. But
you've got std::string references everywhere. Same problem, same solution:
//...
typedef std::string Name;
typedef std::vector<Name NameList;
NameList nameList;
//... |
These will not only make your code easer to maintain, they will also make
your code easier to read.
|
The zip file viewer built into the Developer Toolbox made use
of the zlib library, as well as the zlibdll source additions.
|
