Robert Miles said:
I'm just starting out learning C, but using Windows Vista instead of a
more C-oriented operating system.
So far I've found this on-line tutorial, which looks like a good brief
introduction:
[...]
I just took a very quick look at that tutorial. I can't tell yet
whether the tutorial as a whole is any good, but the things it gets
wrong in the first few paragraphs do not make me optimistic.
Some things it gets wrong:
ANSI issued the first C standard in 1989, not 1988. K&R's 1998 book
(see below) was based on the ANSI standard as it was being developed.
"#include < stdio.h>" is wrong; there's no space after the '<'.
That's probably an HTML markup issue. You'll note that if you
copy and paste one of the examples into a C source file, it won't
compile until you delete the extra space.
"void main()" is wrong, and I'd like to know where the &*^&
the authors got the idea that it's correct; K&R2 certainly
never suggests it. The correct declaration is "int main(void)";
"int main()" is probably acceptable. Many compilers will accept
"void main()" without complaint, but it's particularly important
in C to understand that just because something appears to work,
that doesn't mean it's correct.
To expand on this a bit, there is a standards document that defines
the C programming language (an online version can be found at
http://www.open-std.org/jtc1/sc22/wg14/www/docs/n1256.pdf). There's a
section that defines the allowable signatures for main in a hosted
implementation (such as gcc running under Cygwin), and the choices
are:
int main(int argc, char **argv) /* or char *argv[], the syntax is
equivalent */
or
int main(void) /* the "void" indicates that main takes no
arguments */
or *in some other implementation-defined manner*, meaning that the
implementation has to document it as a legal signature. Unless the
gcc documentation *explicitly* says that "void main()" is kosher (and
I'm pretty sure it doesn't), you shouldn't use it.
To be safe, every time you see "void main()" in the tutorial (at least
until they get up to command line arguments), replace it with "int
main(void)".
Why does this matter? On most modern desktop systems, a program with
main() typed void may run to completion with no *apparent* ill effects
(which is why people still use it), but there are some oddball systems
where the program will crash on exit, or may not even load at all. It
all comes down to a mismatch between what the runtime environment
expects main() to look like, and what the compiler produces.
Skimming through the rest of the tutorial, I don't see any *obvious*
howlers. Their description of array declaration syntax is simplistic
to the point of being wrong, but a proper description of declarators
would take up a chapter by itself. Likewise, their description of the
correspondence between arrays and pointers is similarly simplistic.
Some words about gcc:
Always add the -Wall and -Werror command line options when you invoke
gcc: -Wall enables all warnings, and -Werror treats all warnings as
errors, so you basically have to address all the problems that crop
up.
gcc provides some extensions to the language that aren't supported by
other compilers, and some of these extensions may conflict with a
particular version of the language standard. Use -ansi or -std=c89 to
force gcc to recognize only code that's legal under the 1989 standard,
or -std=c99 to use the additions from the 1999 standard. You don't
want to get into the habit of using compiler-specific extensions when
you don't really *have* to.
For example, to compile the Hello, World program, use the command line
gcc -o hello hello.c -ansi -pedantic -Wall -Werror
The "-o hello" tells gcc to write the executable to a file named
"hello" instead of "a.out".
