Postby ocelot » Tue Sep 21, 2021 11:30 am
Apparently I can't attach text files, but it looks like I can attach a zip file full of text files... here are three quick examples. The first (fly.c) avoids interactive input (because it gets messy) and instead takes its input on the command line when you run it: compile it with gcc -Wall fly.c -o fly, then run it with ./fly 3we.
The second (fly2.c) is your example but there's some additional mess: fflush(stdout) makes the previous print display even though it's not printed a full line yet (by default the output is line-buffered), and then after reading the name with "fgets" it has to remove the return you had to type to enter it from the end of the string because that's how the fgets function works. (The second fgets just ignores everything besides the first character.)
The third (fly3.c) is an improved version that prints on the screen; compile it with gcc -Wall fly3.c -lcurses -o fly3 and run it with ./fly3. (You might need -ltermcap as well as -lcurses, or maybe -lncurses instead of -lcurses, and you might need to change <curses.h> in the file to <ncurses.h> or <ncurses/ncurses.h> or <ncurses/curses.h>, depending on exact system details, and rubbish like this is part of why things get messy.)
Points of note in these:
"printf" prints on the "standard output" (hence "stdout"), which is by default the terminal you run the program in. Likewise, fgets reads from "standard input" (aka "stdin") which is by default also the terminal you run the program in. Either can be redirected to/from (respectively) a file in the Unix shell, which you may remember how to do from DOS, and your program doesn't need to know anything about this.
The string passed to printf can contain "%s", which inserts another string passed as an extra argument. (It can also be %d, which takes an integer, or various other things.) These are handled on the fly when the program runs. Strings (not just printf) can also contain backslash-escapes, where \n gives the end-of-line character, \b is backspace, \t is tab, and there are a few others. These are handled by the compiler when you compile the program, and are fundamentally different from the % widgets in printf.
% outside a string is modulus; random() % 4 == 0 is true 1 in 4 times. Oh, and == (two equals signs) is equality comparison; = (one equal sign) is assignment. IIRC in BASIC both are one equals sign and the BASIC interpreter tries to figure out which you meant from context, which sometimes results in strange things happening.
In C subroutines are called "functions"; "int main(void)" is a function that takes no arguments ("void" is a type name, but means "nothing", empty parentheses mean something else for historical reasons) and returns an integer. "void die(void)" is a function that takes no arguments and returns nothing. "void fly(const char *name)" is a function that takes one argument, "name", which is a string (a pointer to one or more characters which we aren't going to modify, hence "const") -- by convention in C strings are sequences of characters with the end marked by a zero (ascii 0, not the character '0') and you pass them around by pointing to the first character.
Which brings me to pointers -- the thing in C that confuses people the most and that beginners trip on, and that you can't avoid because you really can't do very much without bumping into one. In most languages a variable is a slot you can put a value in; e.g. if you have an integer variable you can put 1 or 2 or 10 into it, because those are integer values. A pointer is a different kind of value; it's a piece of paper that says where to find something else. So if I have a pointer variable whose type says it points to an integer, the pointer values you can put in it are pieces of paper that say where you can find an integer. There's an operator that takes the address of some other variable to make a pointer (it's "&", so "&x" is the address of x) -- this writes down the address on a piece of paper, which you can then pass around. There's also an operator that reads the piece of paper and goes and gets the value from the address it finds; that's "*", so "*y" gets the value that y points to. (This is called "dereferencing" it.) In the case of strings, a string constant like "hello" is stored in the program by the compiler somewhere and the value you get in your program is a piece of paper that says where it is. This value can then be passed to printf, or fly(), or whatever else.
If you have an array, like "char name[64]" in fly2.c (that's like DIM NAME(64) in BASIC), you can use the name of the array as a pointer to the first element. So we can pass this array to fgets(), which fills it in with the input (the sizeof argument says how big it is, which is important for not trying to put too much in, and the stdin argument says where to get the input from) and then we have a string that we can get the length of with strlen and pass to printf for printing. Likewise later when it gets another string "yn", because it's an array of characters we can look at the first character by indexing the array with [0].
NULL is an invalid pointer; basically it's a piece of paper with "oops" written on it, and if you try to dereference it the program will crash.
The problem beginners always have is that they don't really understand that the pointer is separate from the stuff it points to, and it always has to point to something real in the program memory somewhere (that is, the place written on the piece of paper has to be valid) and so they get compile errors when they mix values and pointers, and then "fix" it by changing around the use of & and * until the compiler stops complaining, at which point usually they are doing something other than what they intended and their program crashes when they run it. Notice here (in fly2) that though all the string constants are just passed around (and can be, because the compiler takes care of putting the characters somewhere) we need to explicitly make space to read the inputs into, and then once we've done that we can point at that space and have it work. A typical beginner mistake writing this code, though, is to write "char *name" instead of "char name[64]" -- that just declares a pointer, not an array, and it doesn't point anywhere in particular by default (it's a piece of paper the program picked up off the floor) so if you then try to read input into it, the address on the piece of paper doesn't exist and you crash. (Or sometimes, worse, it's the address of something else in the program and you overwrite that thing, which doesn't ever go well.)
Some other quick notes on the syntax in here:
"static" on a function or global variable means it isn't accessible from other source files; this isn't important until you have more than one source file.
The readstr function in fly3.c implements its own input editing (of the simplest possible form, backspaces only) because... you kinda need to once you're handling screen output explicitly.
"while (1) { ... }" is an infinite loop (the 1 is where the loop condition goes, and the 1 implicitly means 1 not equal to 0) but fortunately the "break" statement further down exits the loop.
#include imports declarations from the system libraries; by default almost nothing is defined (this is good, because it means you don't have to worry about name conflicts with system libraries you never heard of) and you have to import things to use them. <stdio.h>, <stdlib.h>, <string.h>, <ctype.h>, and <time.h> are from the C Standard Library; <unistd.h> and <err.h> are standard Unix addenda to the C Standard Library; and <curses.h> is the standard Unix terminal-window screen drawing library.
The -lcurses you need on the compiler command line also pulls in the curses library, at a different level ,and I'll explain the difference at some later date...
hopefully at least 10% of the above is comprehensible...
-
Attachments
-
- fly.zip
- (1.8 KiB) Downloaded 127 times
)
