Re: Symbol Name Length (Was: STL Memory leak?)
Daniel Pitts wrote:
blargg wrote:
By the way, your naming convention is very verbose, and thus obscures
things. The scope of a variable should play a part in the length of its
name; smaller scope, shorter name. But this is just a style issue.
Not to start a flame war, but I disagree. Names should *always* reflect
the semantics of what they represent as concisely as possible. Take
away all you can, but no more.
My point is that the context is a source of information that need not
be repeated in the name. The smaller the scope, the more the context
can reliably provide it.
For the following, I'm going to ignore the misnaming of the function
as "strcpy", just so I can compare with the original examples rather
than rewriting it to be correct.
For example, I've seen the following two functions, which one is easier
to understand:
char *strcpy(char*a, char*b)
{
char *c = a;
while ((*b = *a) != 0)
{
++b;
++a;
}
return c;
}
char *strcpy(char *source, char *dest)
{
char *ret = source;
while ((*dest = *source) != 0)
{
++dest;
++source;
}
return ret;
}
Let's make it more fair by giving the longer-named one similarly
useless names as "a", "b", and "c":
char *strcpy(char *albatross, char *banana)
{
char *canary = albatross;
while ((*banana = *albatross) != 0)
{
++banana;
++albatross;
}
return canary;
}
Or alternatively, give the single-lettered one better names:
char *strcpy(char*s, char*d)
{
char *r = s;
while ((*d = *s) != 0)
{
++d;
++s;
}
return r;
}
In other words, your comparison was partly between good and poor
names, not just name length. My suggestion wasn't single-letter names,
just the length correlating with scope. For strcpy I'd use the names
"in", "out", and "result". The example I was responding to originally
was
CScreen* newScreen = new CScreen();
list<CScreen*> m_screenList;
m_screenList.push_back(newScreen);
m_screenList.clear(); // does it create a memory leak?
I contend that the following is a significantly clearer way to ask the
same question:
T* t = new T;
list<T*> l;
l.push_back( t );
l.clear(); // does it create a memory leak?
My point is to recognize contextual information that a variable will
be able to unambiguously draw on and avoid duplicating that in its
name, rather than applying a hard rule of always naming a variable
without regard to its scope. I'll point out that in this discussion
and this post itself, each sentence heavily draws on the context set
up by others, otherwise there would be lots of restatement and
verbosity.