The macros are clearer and less error-prone.
No, they aren't. They're less clear. In particular, they have connotations
which are familiar to many programmers, but not to you.
.... Which is to say: They may seem clearer to you. If you never, ever,
want to write code for anyone else, that's fine. If you ever want to write
code which any other person may have to maintain, though, you have to look
into what is clearer *to other people*.
Someone who is experienced in C is going to immediately understand == and
!=. They may well not have any idea what eq and ne are supposed to be.
If they've got experience with perl or shell (common languages for C
programmers to know), they may expect that ne and eq have DIFFERENT
SEMANTICS from != and ==, because that's what those names have been
historically used for.
Anyone who couldn't figure out from the context what those macros meant
need not be doing any coding IMO.
I don't think you understand.
I can guess what they *probably* *should* mean. Probably. I cannot,
however, predict what madness may have driven someone to create them.
If I know that you are the sort of person to use "ne" for !=, I also know
that you are the sort of person to do all sorts of insane things I cannot
reasonably predict. Therefore, I have to go look and see what you did.
Good thing my code is not for anyone else huh.
Silly me. I thought you were posting these because you thought someone
else might use them. Nevermind; I realize now that you have no interest
in working with other people, making anything you could possibly say about
programming of no interest to, well, anyone.
Make me.
I can't, but... I can tell you that I'd never hire you, and if I ever
by some mischance happen to see your name on a list of candidates, it won't
get to the interview stage.
Anything that cleans up ugly C syntax is a boon. I'll further
that and say those who don't create things to abstract away the low level
are not very good coders, or JUST coders. Everything implemented at level
0 is not a good design for any software. C is just a hammer. If you want
more tools, then you have to create them. The couple of macros above are
just tidbits.
They are *shitty* tidbits.
Seriously, I've written a ton of tools for abstracting C. What you're
doing, for the most part, is not abstracting much of anything.
C is inherently obfuscated ("cryptic"). Keywords would be better than the
operators and with the macros, I have the equivalent.
Again, this dooms your macros to be never usable by anyone but you.
You can't use code other people wrote, because if you include your
macros, it will break their code -- both "ne" and "eq" are names that
people use for variables in other code. Other people can't use your
code. You have isolated yourself from any possible interaction with
or cooperation with other programmers.
The macros above
are a teeny tiny step to clean up the langugage.
Trying to turn C into another language doesn't clean it up.
C++ actually defines
macros in the standard such as those, I believe, and like I said, in
these modern times of syntax-highlighting editors, those macros really
come into their own. Try it, your code will look much nicer, be more
readable in that IDE and be less error-prone too.
I don't use IDEs.
Anyway, I just don't believe you. In the last
twenty years of C programming, I don't think I've ever had an error which
could have conceivably been avoided by such macros, but I've seen plenty
of places where they'd have caused problems.
Not if you abstract it away properly.
And therein lies the problem:
You can't, in fact, abstract it away enough to get away from that reality
in C. You can in C++, probably. But in plain C, you will never get away
from this:
*p == p[0]
Any attempt to not count from zero will screw you, because the language
really DOES count from zero. You can write up elaborate macros and
specialized helper functions all you want, but if you're ever going to
use pointers, you will be stuck with a language which counts from zero.
But, on the whole, the question is irrelevant. You are staunchly and
militantly opposed to anything that could lead to cooperation with other
people, you don't care whether your code is useful to other people,
and you haven't yet realized that it could be useful to you to be able to
use other people's code. That, plus the insulting and dismissive tone,
advises me clearly that the time has come to apply lossless compression
to your tiny part of Usenet's signal. *plonk*
-s
