Let's get right to the meat of things. Don't be scared by the amount
of stuff listed up there, there's a lot of important information here and
it's not that hard to learn. We'll cover another method of looping, ways
to add on to the end of sequential files, structured programming, and
"random-access" files. That's a lot of material.
First off, the last of the looping techniques. We've already tried
DO...LOOP and FOR...NEXT, and here comes WHILE...WEND. It's very similar
to a DO...UNTIL loop, and I rarely use it in my programs, but you might
as well learn everything you can. Its basic syntax is as follows:
That's it. Let's say you want to make a simple guessing game. All
it takes is a simple loop, as in the next example.
PRINT "Guessing game!"
number = INT(RND * 10) + 1 'random number from 1 to 10
PRINT "The number is from 1 to 10... go!"
WHILE guess <> 10 'loop until the guess = 10
INPUT "Guess"; guess
tries = tries + 1 'count the number of tries
PRINT "Good job! You got it in"; tries; " tries!"
There's a working, somewhat interesting program in only 10 lines!
We're finally getting somewhere. That's all there is to a WHILE...WEND
loop. So simple, and yet so useful!
We talked about sequential files in Chapter 4. Those were the files
that you could only INPUT from or OUTPUT to at one time. There's one more
way to add to these files, and that is done by using the APPEND command.
You use it just like OUTPUT and INPUT:
OPEN "file.txt" FOR APPEND AS #1
APPEND is just like OUTPUT, except it doesn't erase what's already
in the file before it adds to it. It's useful for ongoing high score lists
and a bunch of other things that I'm sure your creative mind can think of.
Again, not much to it. Just fool around until you get the hang of it.
Moving on, we'll now discuss structured programming. Programs are
huge jumbles of thousands of lines of code, and if everything was just
arranged from top to bottom, it would take forever to find a problem in
the program! Plus, it just looks messy and is hard learn from. So,
the geniuses of the 1960s developed something called "structured program-
ming." Using this technique, we can create "subprograms" and "functions"
in our programs to better arrange our code.
In order to create and edit a subprogram in QBasic, all you have to
do is go to the [E]dit menu on the menu toolbar and choose New [S]UB...
QBasic will then prompt you for its name. Don't get too creative and call
it "Bob" or "Jane," give it a name like "DoGraphics" so you can tell what
the SUB really does.
QBasic will then let you edit the SUB. Program just as you would
normally, and when you're done, go to [V]iew on the toolbar, choose [S]UBs
and then pick your program's filename off of the menu. If you want to go
back and edit your SUB, go to the [V]iew menu, choose [S]UBs and pick your
SUB off the list. You can have as many subroutines as you want in a pro-
gram. Be aware, though, that variables you create in a SUB only are
accessible in the SUB and variables in the main body of the program are
only accessible from the main body of the program unless you make them
SHARED using the following command:
COMMON SHARED variable$, variable2, variable3!
This statement goes after your "DECLARE SUB..." declarations (QBasic
places these statements in your program once you save it) and before any
other executable lines of your program. To make an array SHARED, you just
stick the word SHARED in after the DIM command, like this:
DIM SHARED array$(100)
Make sure that any variables you want to be SHARED (called "global"
variables) are in your COMMON SHARED statement. Otherwise, your program
will turn up a lot of errors. To pass variables on to the SUB as you call
it from the main program, you must change the name of the SUB. While you
are editing it, just use a line like this:
SUB DoBox (x1, y1, x2, y2)
QBasic sticks the "SUB DoBox" in there for you. Now, when you call
the SUB from the main program, use a line like this:
DoBox 30, 20, 50, 20
Otherwise, you can just type the name of the SUB in the main program
to call it up, like this:
As a complement to SUBs, those programming gurus of the '60s also
developed FUNCTIONS. These are similar to SUBs, but they basically just
perfom a specific calculation to return a number. You create them the
same way you would create a SUB, by going to the [E]dit menu, but choose
New [F]UNCTION. You can switch what you're editing the same way. Here's
a short example:
Cube = num * num * num
INPUT "Number"; number
num3 = Cube(number)
PRINT number; "cubed ="; num3
The last topic I'll cover in this tutorial is random-access files.
These files are kind of like database files - they have a set record type
and a number of records. They're very useful for database applications.
To make the record, you have to define it near the top of your program
with a TYPE...END TYPE clause. Here's a short example for an address
nm AS STRING * 40 'set the name as a 40-character string
age AS INTEGER 'set the age as an integer
address AS STRING * 60 'set address as a 60-character string
The next thing you have to do before you open the file is use a
DIM command to set a random-access array up for the TYPE, as follows:
DIM person AS people
Now, you must open the file. You again use the OPEN command, but
now you have to add in two commands: LEN and RANDOM. Here's an example:
OPEN "address.dat" FOR RANDOM AS #1 LEN = LEN(person)
This will open up your random-access file of addresses with the
record length that you set in your TYPE. Now, in order to get records
or put records to a file, you have to use special variable names and
different file commands. Here's a quick example of adding a record to
the file we created above:
INPUT "What record to add"; record
INPUT "Name"; person.nm
INPUT "Age"; person.age
INPUT "Address"; person.address
PUT 1, record, person
As you can see you have to have your DIMmed array name, then a
period, then the variable name you set in your TYPE. Then, you have to
PUT the record to the file using the PUT command (how appropriate). The
syntax for the PUT command is like this:
PUT [filename], [recordnumber], [arrayname]
It's very simple. To get an array from the file, you use basically
the same method, except with the GET command. The GET command has exactly
the same syntax as the PUT command, except it reads from the file into
the array that you specify. Here's an example from the program we have
INPUT "View which record"; record
GET 1, record, person
PRINT "Name"; person.nm
PRINT "Age"; person.age
PRINT "Address"; person.address
That's how you use random-access files. An example is available,
called RANDOM.BAS. If you didn't download it with the .ZIP file, please
download it from http://www.qbasic.com/random.bas. Random-access files
are very useful for a lot of applications, but they're also very complex.
One last thing before I conclude - when an input doesn't fill up all of
the STRING you specified in the array (like in the above example: if
the person's name isn't 40 characters) the variable WILL have all the
extra spaces on the end to fill up the 40 characters. To remedy this,
use the RTRIM$ command, as follows:
personname$ = RTRIM$(person.nm)
This will trim all the extra spaces off of the end of the string.
And that's it for this tutorial. There's a heck of a lot of stuff
here, and if it's confusing, please ask me questions. They might take a
long time to answer, but I need to know how to improve my tutorials so
they help YOU the most.
1. Create a simple database program for addresses and names
using structured programming.