____________________________________________________________________________________
Introduction
____________________________________________________________________________________
QBASIC is a programming language. With a programming language you can tell the computer what you want it to do. It's a lot like giving someone directions to your house. The computer follows each step and does exactly what you tell it. By programming the computer you can solve math problems, create art or music, and even make new games. It's all up to you.
________________________________________
Your First Program
With the blinking cursor ( _ ) at the top-left corner of the screen, type this:
PRINT "Welcome to QBASIC. Your wish is my command."
Make sure it looks exactly like that. The quotation marks (") are very important. If you make any mistakes, use the
PRINT prints things to the screen. Don't forget to put what you want to say in double-quotation marks (").
Learned
• QBASIC screen
• ?
________________________________________
CLS
• Type CLS Clear Screen
Now your program should look like this:
CLS
PRINT "Welcome to QBASIC. Your wish is my command."
PRINT "Programming is fun."
Learned
• CLS
• Shift+F5 To Run app.
________________________________________
- DO...LOOP
DO
PRINT "Saru was here ";
LOOP
Make sure you get the semi-colon (;) at the end of the PRINT line, and the space between the word "here" and the last quotation mark.
Break!
Press the
Learned
• File
New
• DO...LOOP
•
________________________________________
- INPUT
CLS
INPUT "Enter your name: ", Name$
PRINT "Hello, "; Name$; ". How are you today?"
Don't forget the comma (,) between "Enter your name: " and Name$. Run it. When it asks, type your name, then press the
Name$ Variable (things that can change)
Variables
Variables hold letters and numbers. The dollar sign ($) means this variable can hold letters. These are called "string variables". Variables without a dollar sign can only hold numbers.
You can call your variables anything you want. Try going back through this program and changing every "Name$" to "Saru$". What happens when you run it?
PRINT and Variables
When you want to PRINT what's in a variable, leave off the double-quotation marks ("). This program will show you how this works:
CLS
INPUT "Enter your name: ", Name$
PRINT "Name$"
PRINT Name$
The first PRINT statement prints Name$ on the screen. The second PRINT statement prints whatever name you entered.
Learned
• INPUT
• Variables
________________________________________
- IF...THEN
CLS
INPUT "Enter your name: ", Name$
IF Name$="Sam" THEN
PRINT "Go Away!"
ELSE
PRINT "Hello, "; Name$; ". How are you today?"
END IF
You can change the Name$="Sam" to Name$="Ram"
IF...THEN
The "IF..THEN..ELSE..END IF" statement in this program checks to see if Name$ has "Mike" in it. If so, then it does the PRINT statement after the "THEN". If Name$ isn't "Mike", it does the PRINT statement after the "ELSE". "END IF" tells QBASIC that the "IF" is over.
Conditions
The Name$="Sabi" portion of the IF...THEN is called the "condition". With numbers you can also check for "greater than" and "less than":
CLS
INPUT "Enter a number: ", Number
IF Number < 100 THEN
PRINT "Your number was less than 100"
ELSE
PRINT "Your number was greater than or equal to 100"
END IF
If you want to check for "greater than", use "Number > 100". Equals works just like before, "Number = 100". Another option is "not equal" which can be done like this: "Number <> 100".
Learned
• IF...THEN...ELSE
________________________________________
- Numbers
Computers are very good at math. Let's get the computer to do some math for us. Here's a simple multiplication calculator:
CLS
INPUT "Enter the first number: ", A
INPUT "Enter the second number: ", B
PRINT "The answer is: "; A * B
If you have trouble finding the star (or asterisk "*") on the keyboard, it is usually above the number 8. Run it, and enter two numbers. It does an excellent job multiplying for you.
Variables and Math
A and B are variables, just like Name$. Unlike Name$, A and B do not have a dollar-sign after their names. This is because they are only holding numbers, not letters.
Star
"A * B" means "A times B".
Try changing the "A * B" to "A - B" for subtraction. "A + B" will do addition, and "A / B" will do division. Why "/" for division? Because there's no division sign key on the keyboard. At least I haven't found one.
Expressions
"A * B", "A + B", "A - B", and "A / B" are called mathematical expressions, or simply "expressions".
Learned
• Variables with numbers
• INPUT with numbers
• Multiplication, Division, Addition, Subtraction
• Expressions
________________________________________
- SELECT CASE
IF...THEN...ELSE is fine if you only have two things you want to check.
CLS
INPUT "Enter your name: ", Name$
SELECT CASE Name$
CASE "Saru"
PRINT "Greetings, oh powerful master"
CASE "Sabi"
PRINT "Go away!"
CASE ELSE
PRINT "Hello, "; Name$; ". How are you?"
END SELECT
SELECT CASE
Just In CASE
SELECT CASE can also be used with numbers as well as strings.
CLS
INPUT "Enter a number: ", Number
SELECT CASE Number
CASE 1234
PRINT "Thank you for entering the secret number 1234"
CASE 22
PRINT "Well, 22 is an interesting number"
CASE ELSE
PRINT "You must not know the secret number"
END SELECT
Learned
• SELECT CASE
________________________________________
- Equals
CLS
A = 1
B = 2
A$ = "Hello"
PRINT A
PRINT B
PRINT A$
CLS
Count = 1
DO
PRINT Count
Count = Count + 1
LOOP
Did you get it right? Did the output go by way too fast? You'll have to press Break to stop it.
________________________________________
- Random Numbers
RND
RND is a special function that gives us a random number between 0 and 1. We can use this in games to make things interesting. RND is perfect for rolling dice or flipping a coin. First let's see RND in action:
CLS
PRINT RND
PRINT RND
This program will print RND twice. Notice that you'll get two numbers that appear to be unpredictable and random. But, try running the program again. You'll get the same "random" numbers. This means your games would always be the same each time the user runs them. Fortunately, there's a way to fix this.
RANDOMIZE TIMER
Using RANDOMIZE TIMER will make sure the random numbers you get are different each time you run. Try this:
CLS
RANDOMIZE TIMER
PRINT RND
PRINT RND
Useful Random Numbers
CLS
RANDOMIZE TIMER
PRINT RND * 6 + 1
PRINT RND * 6 + 1
QBASIC's INT function can be used to convert a decimal number to an integer (a number without a decimal).
CLS
RANDOMIZE TIMER
PRINT INT(RND * 6 + 1)
PRINT INT(RND * 6 + 1)
Roll the Dice
Here's a program that rolls two dice and prints the value of each. The variables Die1 and Die2 are used to hold the values of each die before printing. In a real game, Die1 and Die2 would be used in some clever way to change the outcome of the game.
CLS
RANDOMIZE TIMER
INPUT "Press ENTER to roll dice...", A$
Die1 = INT(RND * 6 + 1)
Die2 = INT(RND * 6 + 1)
PRINT "Die 1: "; Die1
PRINT "Die 2: "; Die2
________________________________________
- The Fortune Teller
Here's a fun program that uses most of what we've learned so far to make a "Magic 8 Ball".
CLS
RANDOMIZE TIMER
PRINT "I am the magical Fortune Teller."
INPUT "Think of a question and press enter for your answer...", A$
Answer = INT(RND * 5 + 1)
SELECT CASE Answer
CASE 1
PRINT "Yes, definitely."
CASE 2
PRINT "Ask again, later."
CASE 3
PRINT "No way!"
CASE 4
PRINT "It is certain."
CASE 5
PRINT "Yes."
END SELECT
As always, go ahead and customize it. Change "No way!" to "You bet!" to get a Fortune Teller that never says "No".
Adding CASEs
Go ahead and try adding a new fortune. You'll need to change
Answer = INT(RND * 5 + 1)
to
Answer = INT(RND * 6 + 1)
since there will be 6 fortunes now. Then you will need to add a "CASE 6" and a PRINT to print the new fortune.
________________________________________
- DO...WHILE
CLS
DO
INPUT "Enter the first number: ", A
INPUT "Enter the second number: ", B
PRINT "The answer is: "; A * B
INPUT "Would you like to do it again (y/n)? ", Answer$
LOOP WHILE Answer$="y"
The condition on the LOOP WHILE line is the same as a condition we might use in an IF...THEN.
________________________________________
- OR and LEFT$
CLS
DO
INPUT "Enter the first number: ", A
INPUT "Enter the second number: ", B
PRINT "The answer is: "; A * B
INPUT "Would you like to do it again (y/n)? ", Answer$
LOOP WHILE Answer$="y" OR Answer$="Y"
This version will allow the user to enter "y" or "Y" and the program will run again. We can get even more clever by using LEFT$ like this:
CLS
DO
INPUT "Enter the first number: ", A
INPUT "Enter the second number: ", B
PRINT "The answer is: "; A * B
INPUT "Would you like to do it again? ", Answer$
FirstLetter$ = LEFT$(Answer$, 1)
LOOP WHILE FirstLetter$="y" OR FirstLetter$="Y"
This version will let the user enter "Yes", "yes", or just about anything that starts with a "y" because LEFT$ is used to only look at the first character in their answer. You could even enter "yep" or "YEAH!" and the program will begin again.
LEFT$
LEFT$ can be used to take a certain number of letters from the left side of a string variable
A$="TEST"
Then LEFT$(A$,2) will give us "TE". LEFT$(A$,3) will give us "TES".
The first "parameter" you pass to LEFT$ is the string you want to work with.
The second parameter you pass to LEFT$ is the number of characters (letters) you want.
INPUT "Enter something:", A$
PRINT A$
PRINT LEFT$(A$,1)
PRINT LEFT$(A$,2)
PRINT LEFT$(A$,3)
This program will print the first character of whatever you enter, followed by the first two characters, followed by the first three characters:
Enter something: Ram
Ram
R
Ra
Ram
QBASIC also provides a RIGHT$() in case you were curious, and it works just like LEFT$().
INPUT "Enter something:", A$
PRINT A$
PRINT RIGHT$(A$,1)
PRINT RIGHT$(A$,2)
PRINT RIGHT$(A$,3)
Here's an example of what that program will do:
Enter something: Hari
Hari
i
ri
ari
________________________________________
- COLOR
Tired of all this black and white? Then the COLOR statement is for you.
CLS
COLOR 2, 0
PRINT "That's ";
COLOR 3, 0
PRINT "more ";
COLOR 5, 0
PRINT "like it!"
Color takes two numbers. The first number is the foreground color. The second number is the background color.
Color Numbers
• 0 - Black
• 1 - Blue
• 2 - Green
• 3 - Cyan
• 4 - Red
• 5 - Magenta
• 6 - Yellow
• 7 - White
There are plenty of other colors too. Try the numbers from 8 through 15 to see what colors you get. Basically, if you add 8 to any of the above colors, you get brighter versions of the same color. Take blue which is 1 and add 8 and you get 9 which is bright blue.
Blinking
Adding 16 to a color number gives you a blinking version. This doesn't work in a DOS window, though. Press
CLS
COLOR 28, 0
PRINT "*** WARNING ***"
COLOR 15, 0
PRINT "Programming can be too much fun!"
________________________________________
- FOR...NEXT
A New Counter
FOR...NEXT is a loop like DO...LOOP, but a FOR...NEXT loop has its own counter built in.
CLS
FOR I = 1 TO 10
PRINT I
NEXT I
A Color Chart
Here's a color chart program using a FOR...NEXT loop.
CLS
FOR I = 1 TO 15
COLOR I, 0
PRINT I; "*** COLOR ***"
NEXT I
STEP
FOR...NEXT can also do "step counting". Try this:
CLS
FOR I = 2 TO 20 STEP 2
PRINT I
NEXT I
That will count by 2's from 2 to 20. STEP tells QBASIC what to count by.
FOR...NEXT can also count backwards if you use a negative STEP value:
CLS
FOR I = 10 TO 1 STEP -1
PRINT I
SLEEP 1
NEXT I
PRINT "BLAST OFF!"
"SLEEP 1" tells QBASIC to wait for one second, then continue.
________________________________________
- Sound
If you just need a beep in your program, you can use BEEP:
CLS
INPUT "Press Enter to hear a beep", A$
BEEP
SOUND lets you play a beep and tell it how high or low the beep will be, and how long it will last. This program makes a 1000Hz beep for about 1 second:
SOUND 1000, 18
SOUND is good for making sound effects. Here's a bomb dropping:
FOR I = 4000 TO 1000 STEP -5
SOUND I, .1
NEXT I
If you want to play a song, PLAY is exactly what you need.
PLAY "e8 d8 c8 d8 e8 e8 e4"
PLAY is like a little programming language inside of QBASIC. "e8" means play an eighth note "e". If you are familiar with sheet music, this will make sense. Here's a scale:
PLAY "c8 d8 e8 f8 g8 a8 b8 > c4"
The ">" greater than sign means "go up one octave". There are many more special commands in PLAY. Check the QBASIC help for a list of all of them.
PLAY and Triplets
Here's a familiar tune that uses a trick to do triplets.
PLAY "T180
PLAY "T180 c8
PLAY "T180 c8
PLAY "T180 c8
Since PLAY doesn't do triplets, you have to modify the tempo to get the right rhythm. PLAY begins with a default tempo of "T120" which means 120 quarter notes per minute. In the above song, we switch to T180 which is the triplet tempo for T120. By multiplying our tempo by 1.5, we get the triplet tempo. When the triplets are done, we switch back to the regular tempo. You can see in the above example that we switch back and forth between the main tempo (T120) and the triplet tempo (T180) several times as needed.
As with everything, there's more than one way to do triplets. 8th note triplets can also be called 12th notes, like this:
PLAY "
PLAY "c12
PLAY "c12
PLAY "c12
Using this technique, 16th note triplets are 24th notes, etc.... You just multiply the note value by 1.5 instead of changing the tempo.
Each of these techniques has its advantages and disadvantages. The tempo-changing technique uses more space, but the notes retain their values. The 12th note technique is more compact, but not as easy to understand. Which one you use is up to you. Just make sure the next person to read your code understands what you are doing. Comments are a good idea.
________________________________________
- LOCATE
LOCATE allows you to print in a specific place on the screen.
CLS
LOCATE 5, 10
PRINT "Here"
LOCATE 20, 70
PRINT "There"
The two numbers after LOCATE are the coordinates where the print will be. Just like coordinates in math class, these numbers give the row and the column. The first number in LOCATE is the row, or how far down the screen the print will start. The second number is the column, or how far over the print will start.
Let's use some random numbers, COLOR and LOCATE to make a more interesting version of our first looping program:
CLS
DO
Row = INT(RND * 23 + 1)
Column = INT(RND * 79 + 1)
LOCATE Row, Column
Color1 = INT(RND * 15 + 1)
COLOR Color1, 0
PRINT "Ted was here!";
LOOP
Kind of messy, but interesting.
How about a clock?
CLS
DO
LOCATE 1, 1
PRINT TIME$
SLEEP 1
LOOP
TIME$ is a special variable that contains the current time. Press Break to stop.
________________________________________
- WIDTH
Use WIDTH 40 for big text. It changes the entire screen to wide text mode. Use WIDTH 80 to go back to normal size text.
SCREEN 0
WIDTH 40
CLS
PRINT "Wow! This is big!"
INPUT "Press
WIDTH 80
PRINT "That's more like it."
Unfortunately, you won't see the big text in a window. You'll have to press
________________________________________
- CHR$
There are many special symbols and other characters you can display that aren't on the keyboard.
CLS
PRINT CHR$(1); CHR$(2)
That prints a couple of smiley faces. There are plenty of other characters too. This program will show you many, but not all of them:
CLS
FOR I = 32 to 255
PRINT I; CHR$(I); " ";
NEXT I
________________________________________
- Graphics
So far, we've only been dealing with text (words and numbers). How do we do pictures in QBASIC? First, we need to use SCREEN to change from text mode to graphics mode.
SCREEN
SCREEN lets you select a "graphics" screen instead of the "text" screen we've been using. This will let you draw pictures. In the next program, we'll use DRAW to draw a square on the screen in SCREEN 12 graphics mode.
SCREEN 12
CLS
DRAW "D100 R100 U100 L100"
There are many other SCREEN numbers you can use, but 12 is probably the easiest to work with. It gives you a lot of space and the color numbers are familiar. QBASIC Help explains all the possible values of SCREEN. You can always try them and see what happens.
DRAW
DRAW is kind of like the turtle in the programming language Logo. With DRAW, you can move around the screen and draw lines along the way. In the above example we used the following DRAW commands:
• D100 - Go down 100 units
• R100 - Go right 100 units
• U100 - Go up 100 units
• L100 - Go left 100 units
DRAW can do a lot more than that. It is like PLAY. It's a small programming language inside of QBASIC. Look at QBASIC Help for a complete description of everything it can do. Here's a filled in box:
SCREEN 12
CLS
DRAW "C15 D100 R100 U100 L100 BF1 P15,15"
"C15" sets the color to bright white. "BF1" moves into the square, then "P15,15" fills it with bright white. Finally, here's something very Logo-like:
SCREEN 12
CLS
FOR I = 0 TO 360 STEP 10
DRAW "D100 R100 U100 L100 TA" + STR$(I)
NEXT I
"TA" means to turn to a specific angle. STR$ converts the value in I to a string. This lets DRAW turn to the angle in the variable I. It's not quite as easy as Logo, but it's still pretty impressive.
LINE
QBASIC also lets you draw using a coordinate system. It's like drawing graphs on graph paper. Try this:
SCREEN 12
CLS
LINE (0, 0)-(320, 240), 15
LINE lets you draw a line between two points. The points are specified in (x, y) coordinates. You may have seen this when learning about graphs in math class. In QBASIC, the coordinates are almost the same. The only thing that is different is the Y coordinate. In QBASIC, the Y coordinate is upside down. "0" is at the top, and bigger numbers go toward the bottom of the screen.
"LINE (0, 0)-(320, 240), 15" draws a line starting at coordinate (0, 0) which is the upper left corner of the screen. The line ends at (320, 240) which is the center of the screen. The last number is the color (15 which is bright white).
Box
By adding a "B" to the end of a LINE statement, you can draw a box. Try this:
SCREEN 12
CLS
LINE (0, 0)-(320, 240), 15, B
The first coordinate is the upper left corner while the second coordinate is the lower right.
Try "BF" instead of "B". Interesting?
CIRCLE
QBASIC can also draw circles using the CIRCLE statement:
SCREEN 12
CLS
CIRCLE (320, 240), 100, 15
The coordinate (320, 240) tells the computer where to put the center of the circle. "100" is the radius, or how big the circle will be. "15" is the color number (bright white again).
PAINT
Notice how that circle was not filled in. LINE has a "BF" option that will let us fill in the boxes it draws. CIRCLE has no such option, so we have to use PAINT:
SCREEN 12
CLS
CIRCLE (320, 240), 100, 15
PAINT (320, 240), 15, 15
PAINT fills an area with a color. It stops painting when it runs into a certain color on the screen. The coordinate (320, 240) tells PAINT where to start filling in, and the first "15" tells PAINT to use bright white as the paint color. The second "15" tells PAINT to stop painting when it runs into anything that is bright white.
Circle Art
Concentric circles are very easy to draw:
SCREEN 12
CLS
FOR I = 5 TO 200 STEP 5
CIRCLE (320, 240), I, 15
NEXT I
With CIRCLE, PAINT and some random numbers, we can make some interesting pictures:
SCREEN 12
CLS
FOR I = 1 TO 50
X = INT(RND * 640)
Y = INT(RND * 480)
R = INT(RND * 100)
Color1 = INT(RND * 16)
CIRCLE (X, Y), R, Color1
PAINT (X, Y), Color1, Color1
NEXT I
- INKEY$
Up to now, we've been using INPUT to get things from the keyboard. The problem with INPUT is that our program stops until the user presses the enter key. Wouldn't it be nice to keep the program running and still be able to get input from the keyboard? INKEY$ will let you do this. Using INKEY$ is very important if you want to make "real-time" game programs.
Let's fix the clock program to let the user press any key to stop the program. This way the user doesn't have to know about the Break key.
CLS
LOCATE 3, 1
PRINT "Press any key to exit"
DO
LOCATE 1, 1
PRINT TIME$
SLEEP 1
LOOP WHILE INKEY$ = ""
Not bad at all. Now we don't need to teach the user about the Break key. We can do the same thing in any of our other programs that need the Break key. If the user does not press a key, INKEY$ returns nothing or "".
This next program will sit in a loop getting keys from the keyboard with INKEY$ and printing them to the screen:
CLS
DO
Key$ = INKEY$
IF Key$ <> "" THEN
PRINT Key$;
END IF
LOOP
That little program can be used to find the various secret codes used by INKEY$ to let you know the arrow keys have been pressed. This is very useful in game programming where the arrow keys might control a player in a game. If you press an arrow key, you'll see that a space and a letter are generated.
________________________________________
- String Functions
Concatenation
Concat-uh-what?! It's just a fancy word for putting things together, one after another. It's much easier done than said. When you use the plus-sign "+" with strings, it doesn't add them up. Instead, it puts them together.
A$ = "Hello "
B$ = "there!"
C$ = A$ + B$
PRINT C$
That will print "Hello there!" to the screen.
LEFT$() and RIGHT$()
LEFT$() and RIGHT$() let you work with parts of strings. Try this example:
A$ = "Ted Felix"
B$ = LEFT$(A$, 3)
PRINT B$
LEFT$(A$, 3) means "take 3 characters from the left of A$". Since the 3 characters on the left happen to be "Ted", this program prints "Ted" as expected. Try changing the number to 2 or 5 and see what happens.
Once you understand LEFT$(), RIGHT$() is easy. Let's try it:
A$ = "QBASIC is cool"
B$ = RIGHT$(A$, 4)
PRINT B$
RIGHT$(A$, 4) means "take 4 characters from the right of A$". This gives us "cool".
MID$()
LEFT$() gives us something from the left side of a string. RIGHT$() gives us something from the right side of the string. MID$() gives us something from the middle of a string. Try this:
A$ = "one two three"
B$ = MID$(A$, 5, 3)
PRINT B$
MID$(A$, 5, 3) means "take 3 characters from the middle of A$, starting at the fifth character". This gives us the word in the middle: "two".
You can also use MID$() to change a portion of what is in a string variable. Try this:
A$ = "cabinet"
PRINT A$
MID$(A$, 4, 2) = "ar"
PRINT A$
Here, we replaced the "in" in cabinet with "ar". This gives us a completely different word.
This would be a pretty sneaky way to hide something like a password in a program. Someone who didn't know how to program in QBASIC might not be able to figure it out.
LCASE$() and UCASE$()
If you need to convert a string to all uppercase or all lowercase, UCASE$() and LCASE$() are exactly what you need.
A$ = "Fly Away With Me"
PRINT A$
PRINT UCASE$(A$)
PRINT LCASE$(A$)
You can use UCASE$() and LCASE$() to do "case-insensitive" tests. In other words, upper and lower case are ignored. Here's an improvement to a previous program.
CLS
INPUT "Enter your name: ", Name$
IF LCASE$(Name$) = "mike" THEN
PRINT "Go Away!"
ELSE
PRINT "Hello, "; Name$; ". How are you today?"
END IF
In this new version, the user can type "mike", "Mike" or even "MIKE" and the name will be recognized.
STRING$() and SPACE$()
Let's say you need to print 20 stars on the screen in a line. You could do it like this:
PRINT "********************"
But, there has got to be a better way. How about with a FOR loop?
FOR I = 1 to 20
PRINT "*";
NEXT I
That works well, but QBASIC provides an even easier way to do this with STRING$().
PRINT STRING$(20, "*")
The first argument to STRING$() is the number of times you want a character repeated. The second argument is the character you want to repeat. So, STRING$(20, "*") means "give me 20 stars".
If you want to print a lot of spaces, you could do it with STRING$():
PRINT "A"; STRING$(20, " "); "B"
Or you can use SPACE$().
PRINT "A"; SPACE$(20); "B"
FOR loops always make things interesting:
FOR I = 0 to 20
PRINT SPACE$(I); "QBASIC!"
NEXT I
LEN()
LEN() gives you the length of a string. Try this:
A$ = "Hello"
PRINT LEN(A$)
As expected, that should print the number 5 since the word "Hello" has 5 characters.
LEN() is handy in FOR loops when you aren't sure how long the string is, and you don't feel like counting it yourself:
A$ = "Hello QBASIC!"
FOR I = 1 to LEN(A$)
PRINT LEFT$(A$, I)
NEXT I
LEN() is very useful when you want the user to provide the string. Try this:
INPUT "Enter a string: ", A$
PRINT "The string you entered was"; LEN(A$); "characters long."
CHR$() and ASC()
Computers really only know about numbers. To make strings of letters, computers convert letters to numbers so they can work with them. CHR$() and ASC() let you do the same kinds of conversions.
CHR$() converts a number to a character. We've already seen this in a previous chapter. Try this:
FOR I = 14 to 255
PRINT I; CHR$(I); " ";
NEXT I
That program displays all the character numbers from 14 through 255 followed by the characters that they represent. CHR$() is very useful for getting characters that aren't on the keyboard. Like this:
PRINT STRING$(40, CHR$(1))
There are some very interesting characters between CHR$(1) and CHR$(31). As an example, CHR$(7) makes a beep. Try it:
PRINT CHR$(7)
There are other interesting things as well. Play around with CHR$() a bit, and you'll find several.
ASC() is the opposite of CHR$(). ASC() takes a character and tells you its number. Try this:
PRINT ASC("A")
That program prints 65 because the character code for a capital "A" is 65. The code that QBASIC uses to convert letters to numbers is called "ASCII" (pronounced "askee").
INSTR()
INSTR() lets you search for a string in another string. If it finds the string, it will tell you where it is. Try this:
A$ = "Hello everyone"
PRINT INSTR(A$, "every")
That program prints "7" because "every" is found at the 7th position in "Hello everyone". If the string isn't found, INSTR() returns zero.
INSTR() can come in very handy when you want to break a string into pieces:
A$ = "two pieces"
SpacePos = INSTR(A$, " ")
PRINT LEFT$(A$, SpacePos)
PRINT RIGHT$(A$, LEN(A$) - SpacePos)
________________________________________
- Comments and Constants
Most programming languages allow you to add notes to your programs that are ignored by the computer. This lets you explain what you've done to someone else who might read your program later. In QBASIC we use the apostrophe (') to begin a comment. Here's an example:
' A program to draw boxes all over the screen
' This is a comment, QBASIC will ignore it
SCREEN 12
CLS
' Draw 50 boxes
FOR I = 1 TO 50
' Pick the location of the box
X1 = INT(RND * 640)
Y1 = INT(RND * 480)
X2 = INT(RND * 640)
Y2 = INT(RND * 480)
' Pick the color for the box
Color1 = INT(RND * 16)
' Draw the box
LINE (X1, Y1) - (X2, Y2), Color1, BF
NEXT I
The computer will ignore all those comment lines, but us humans can read them and remember how a program works. Good programmers use comments to help others understand what they have done. Comments can also help us remember what we did when we come back to a program after working on something else for a while.
Constants
Another way to make your programs easier to understand is to use constants. Constants look and act like variables, but they cannot be changed. Here's a useful program:
CONST Pi = 3.141593
INPUT "Enter the radius of a circle: ", Radius
PRINT "The circumference is:"; 2 * Pi * Radius
PRINT "The area is:"; Pi * Radius * Radius
If we didn't use the constant Pi, we would have to copy the number 3.141593 two places in the above program. Using a constant makes the program easier to read and understand. It also keeps us from making mistakes when copying.
________________________________________
- Sub-Procedures (SUBs)
When programs get big, you need to break them into smaller pieces that are easier to work with. QBASIC calls these pieces "sub-procedures" or SUBs. Other programming languages have other names, like procedures, subroutines, or subprograms.
To work with SUBs in QBASIC, we need to look at the "SUBs" dialog box which shows us a list of our SUBs. Select "View
SUBs..." from the menu to bring up the SUBs dialog box. You can also press the F2 key to get there more quickly. In here, you can select a SUB to work with, or you can select the main module. If you are just starting with a clean slate (File
New) you'll see that the main module is called "Untitled", and there are no SUBs.
You can define a new SUB in QBASIC simply by typing it in. This will jump you to the view of the new SUB. Try typing this:
SUB DrawCircle
CIRCLE (320, 240), 100, 15
END SUB
Notice that after you pressed enter on the first line, you were taken to a new screen with just your new SUB in it. Now, if you go to the SUBs dialog box (View
SUBs...), you can see that you have a SUB named "DrawCircle" and a Main Module named "Untitled".
Now we need to go back to the Main Module ("Untitled") to actually use the new SUB. From the menu, select View
SUBs... to get the SUBs dialog box. Now double-click on "Untitled" to get back to the Main Module. The screen will go blank, but don't worry, your SUB is still out there. Now type this in and run it:
SCREEN 12
CLS
DrawCircle
See? DrawCircle did what it was supposed to do.
Let's try adding another SUB. See if you can remember the steps on your own. Refer back to the previous example if you need help.
SUB PlayMary
PLAY "e8 d8 c8 d8 e8 e8 e4"
END SUB
Now we need to change the Main Module to use our new SUB. So, go back to the Main Module, and change it to look like this:
SCREEN 12
CLS
DrawCircle
PlayMary
Now run it and you should see the circle and hear the song.
Dividing programs into smaller pieces like this will help you make sense out of big programs.
Arguments
Sometimes you want to pass numbers or strings to a SUB. QBASIC lets you do this. Here is a new version of the DrawCircle SUB:
SUB DrawCircle2 (Radius)
CIRCLE (320, 240), Radius, 15
END SUB
This version lets us pass in the Radius. When we do this, Radius is called a "parameter" or "argument" to our SUB. Here's how we would then pass an argument from the Main Module:
SCREEN 12
CLS
DrawCircle
DrawCircle2 20
PlayMary
We could also do something like this in our Main Module:
SCREEN 12
CLS
FOR I = 5 TO 200 STEP 5
DrawCircle2 I
NEXT I
Changing Arguments
If you need to tell the main module something, you can change one of the arguments in your SUB, and the main module will see the change.
CLS
I = 0
AddOne I
PRINT I
SUB AddOne (X)
X = X + 1
END SUB
When you run that program, it will print the value 1 on the screen. This is because the value of I is changed by the AddOne SUB. If you only need to return one value, a FUNCTION is sometimes a better choice. FUNCTIONs are described later.
Arguments That Don't Change
If you happen to put parentheses () around an argument, that argument will not be changed by the SUB. Try this change to the last program:
CLS
I = 0
AddOne I
PRINT I
' Add these two lines:
AddOne (I)
PRINT I
SUB AddOne (X)
X = X + 1
END SUB
This will print 1 and then 1 again. The parentheses around the "I" keep the SUB from making any changes to I.
Scope
What if we had variables in the Main Module and in a SUB that happen to have the same name. Would they be the same variable? Let's find out. Enter this SUB:
SUB Scope
PRINT "Scope says: "; X
X = 23
END SUB
And this Main Module:
X = 15
Scope
PRINT "Main Module says: "; X
And run it. What happened? Scope said "0" because to Scope, X was a new variable. Main Module said 15, because Scope didn't change Main Module's X, it changed it's own X. Scope's X and Main Module's X are different variables.
Variables that you create in a SUB cannot be seen by the Main Module. Variables in the Main Module cannot be seen by a SUB. If you need to share variables, you can pass them as arguments to the SUB.
Global Data
It is possible to make variables in the Main Module available to SUBs without passing them as arguments. Add a "SHARED X" to the Scope SUB like this:
SUB Scope
SHARED X
PRINT "Scope says: "; X
X = 23
END SUB
Now when you run it, you'll see that the Scope SUB can now see the Main Module's X. Scope no longer has its own X. This is called "Global Data" (since it can be seen by everyone) and should be avoided if you can. Most programmers consider this dangerous since it is hard to know which SUB might change a global variable.
You can also make a variable global to all SUBs from the Main Module by adding a "DIM SHARED" to the main module before you set X to 15:
DIM SHARED X
X = 15
Scope
PRINT "Main Module says: "; X
This makes it easier to see which variables are global since they can be found in the Main Module. The problem is that this makes a variable global to every SUB in your program. Usually, only some SUBs need to see a global variable. It is better to use SHARED within your SUB in that case.
Object Oriented Programming
When you start worrying about SUBs and the Main Module sharing variables, you are probably ready to begin learning Object Oriented programming. Object Oriented programming makes it easier to share variables between SUBs and still write code that is easy to understand. Visual BASIC, Java, and C# are programming languages that provide Object Oriented programming features, and are fairly easy to learn.
STATIC
Notice that each time you call a SUB, its variables are lost after the SUB is over. Here's an example:
SUB Counter
C = C + 1
PRINT C
END SUB
CLS
Counter
Counter
Counter
Not a very good counter, since it always prints "1". We can use STATIC to tell QBASIC that we don't want C to go away after the SUB is over. Then we will get the behavior we expect. Change the Counter SUB like this:
SUB Counter
STATIC C
C = C + 1
PRINT C
END SUB
That's much better.
Object Oriented programming languages offer many ways to avoid the use of STATIC variables. If you find yourself making lots of STATIC variables, it is probably time to learn an Object Oriented programming language.
Functions
Functions are just like SUBs, but they return a value. Here's an example:
FUNCTION Add (X, Y)
Add = X + Y
END FUNCTION
And here's a Main Module to go with it:
PRINT Add(3, 4)
Well, I DECLARE!
As you've been entering the example programs in this chapter, you may have noticed that the QBASIC editor adds "DECLARE" statements to the programs. Why does it do this? The DECLARE statement is a warning to QBASIC to let it know that there are SUBs or FUNCTIONs in this program. Without this warning, QBASIC would have no idea what we mean when we call a SUB or FUNCTION. It would think it had found a syntax error and the program would stop.
Fortunately, QBASIC handles making DECLAREs for us. Unfortunately, in larger programs, it might put the DECLAREs someplace that looks ugly. Fortunately, you can move the DECLAREs anywhere you want (as long as it is before the FUNCTION or SUB is first used) and QBASIC still takes care of the rest.
________________________________________
- Data Structures
Built-In Types
QBASIC offers five built-in types. Each of these types can be specified by a single character after the variable name. You can also specify a type using a DIM statement. It is important to pick the right types when you are writing a program. The following descriptions of each type will help you make the right decisions.
Single-Precision
The single-precision type handles numbers with decimals. You can go up to seven digits with a single-precision variable. In a DIM statement, use "SINGLE" to create a single-precision variable. The type-character for a single-precision variable is "!". Unless you do something special, any variable without a type character is single-precision. Here are some examples of creating and using single-precision variables:
X = 1.5
DIM Y AS SINGLE
Y = 2.1
Z! = 2.5
PRINT X; Y; Z!
Notice that the DIM statement can be used to tell QBASIC the type of a variable. Then you don't need to use a type character for that variable.
String
The string type handles strings of characters. You cannot do math with string variables. In a DIM statement, use "STRING" to create a string variable. The type-character for a string variable is "$". Here are some examples of creating and using string variables:
X$ = "Hello"
DIM Y AS STRING
Y = "Goodbye"
PRINT X$
PRINT Y
Integer
The integer type handles numbers without decimals. Integers may range from -32768 to 32767. Math with integers may be faster than math with single-precision variables. For programs that have to run very fast, using integers might be useful. In a DIM statement, use "INTEGER" to create an integer variable. The type-character for an integer variable is "%". Here are some examples of creating and using integer variables:
X% = 32
DIM Y AS INTEGER
Y = 55
PRINT X%; Y
Since math with integers is very fast, you will commonly see the following line near the beginning of QBASIC programs:
DEFINT A-Z
This tells QBASIC to stop assuming that every variable is single-precision, and instead to assume that all variables are integers. This way you don't need to use DIM or the "%" symbol throughout your program to make all your variables integers.
Long-Integer
The long-integer type handles numbers without decimals. Long-integers may range from -2147483648 to 2147483647. Math with long-integers is usually almost as fast as math with integers. For programs that have to run very fast, using long-integers might be useful. In a DIM statement, use "LONG" to create a long-integer variable. The type-character for a long-integer variable is "&". Here are some examples of creating and using long-integer variables:
X& = 65536
DIM Y AS LONG
Y = 121072
PRINT X&; Y
Double-Precision
The double-precision type handles numbers with decimals. You can go up to fifteen digits with a double-precision variable. Double-precision variables are used where very accurate math is needed. In a DIM statement, use "DOUBLE" to create a double-precision variable. The type-character for a double-precision variable is "#". Here are some examples of creating and using double-precision variables:
X# = 3.14159265358979
DIM Y AS DOUBLE
Y = 1.23456789012345
PRINT X#; Y
Arrays
An array lets you store a list of things. Arrays are very similar to variables, but they hold more than one thing. Try this:
N$(0) = "Ted"
N$(1) = "Jack"
N$(2) = "Jill"
N$(3) = "Fred"
FOR I = 0 TO 3
PRINT N$(I)
NEXT I
The number inside the parenthesis "(1)" is called the "subscript". N$(0) is usually pronounced "N dollar sub zero", although I've also heard it called "N string sub zero".
Arrays can also store numbers.
FOR I = 0 TO 10
A(I) = I * 2
NEXT I
FOR I = 0 TO 10
PRINT A(I)
NEXT I
Arrays are limited to holding only 11 items (0 through 10). If you go over 10, you'll get a "Subscript out of range" error. To make bigger arrays, you can use DIM to tell QBASIC how big the array will be:
DIM A(20)
FOR I = 0 TO 20
A(I) = I * 2
NEXT I
FOR I = 0 TO 20
PRINT A(I)
NEXT I
Arrays are perfect for programs that need to keep a list of things. You could use arrays to make a phone book program, or a program that keeps track of the people in your class at school.
TYPE
Sometimes you'll want to put a bunch of different kinds of variables together because all together they describe something. QBASIC's TYPE statement lets you create your own collections of variables. Here's an example:
TYPE FriendType
FullName AS STRING * 20
PhoneNumber AS STRING * 14
END TYPE
DIM Friend AS FriendType
Friend.FullName = "Joe Blow"
Friend.PhoneNumber = "1-310-555-1212"
PRINT Friend.FullName; ": "; Friend.PhoneNumber
TYPE makes our new type, or collection of variables. DIM makes a new variable of that type. When we work with types, we use the variable name, followed by a dot ("."), followed by the name of the variable in the TYPE.
Since TYPE lets you use a single variable to represent a collection of variables, you can use TYPE to pass many parameters to a SUB at once. This may be a good way to avoid using SHARED too much in a SUB.
In QBASIC, a TYPE can hold any of the built-in types. A TYPE can also hold another TYPE. However, a TYPE cannot hold an array. Visual BASIC allows that, but not QBASIC.
A Database
Using arrays and TYPEs together allows you to create what is known as a database. Try this:
TYPE FriendType
FullName AS STRING * 20
PhoneNumber AS STRING * 14
END TYPE
' The database
DIM Friends(2) AS FriendType
' Fill the database with names and numbers
Friends(0).FullName = "Joe Blow"
Friends(0).PhoneNumber = "1-310-555-1212"
Friends(1).FullName = "Jack Sprat"
Friends(1).PhoneNumber = "1-340-555-6545"
Friends(2).FullName = "Carol Christmas"
Friends(2).PhoneNumber = "1-350-555-2421"
' Print out the entire database
FOR I = 0 TO 2
PRINT Friends(I).FullName; ": "; Friends(I).PhoneNumber
NEXT I
________________________________________
- Type Conversion
STR$() and VAL()
Up to now, we've been using string variables to hold strings and number variables to hold numbers. What if we really need to do some math with numbers that are in a string variable? Or maybe we need to get some numbers into a string variable somehow. QBASIC provides the STR$() and VAL() functions to help us out.
STR$() will let us convert from a number to a string. Like this:
A = 25 ' A can only hold numbers
PRINT A
B$ = STR$(A) ' Convert A to a string, store in B$
PRINT B$
VAL() will let us convert from a string to a number. Like this:
A$ = "25" ' Can't do any math with a string variable
PRINT A$
B = VAL(A$) ' Convert A$ to a number, store in B
PRINT B
Converting Numbers
Need to cover CINT(), FIX(), INT(), CDBL(), CSNG(), CLNG()
________________________________________
- DATA and READ
Loading an array with a lot of values can get pretty boring.
' Load up the array
A(0) = 10
A(1) = 24
A(2) = 31
A(3) = 15
A(4) = 67
A(5) = 34
A(6) = 87
A(7) = 92
A(8) = 14
' ... This could go on for quite a while
FOR I = 0 TO 8
PRINT A(I)
NEXT I
To save space, and typing, QBASIC provides the DATA and READ statements. You can place a list of data values in a DATA statement and read them into an array using READ. The following program will do exactly what the previous program does.
DATA 10, 24, 31, 15, 67, 34, 87, 92, 14
FOR I = 0 TO 8
READ A(I)
NEXT I
FOR I = 0 TO 8
PRINT A(I)
NEXT I
QBASIC skips the DATA statements in the code. It only pays attention to them when it finds a READ statement. Each time a READ happens, QBASIC takes a value from the DATA statement and places it in the variable in the READ statement.
RESTORE
RESTORE tells QBASIC which DATA statement to start READing from. You might need to load several different arrays in your program. RESTORE lets you organize the DATA statements any way you want.
Names:
DATA Fred, Joe, Jack, Sue
Values:
DATA 10, 24, 31, 15, 67, 34, 87, 92, 14
' Start with the DATA statement after "Values:"
RESTORE Values
FOR I = 0 TO 8
READ A(I)
NEXT I
' Start with the DATA statement after "Names:"
RESTORE Names
FOR I = 0 TO 8
READ N$(I)
NEXT I
RESTORE tells QBASIC to start reading at the next DATA statement after a label. A label is a name like "Names:" or "Values:". Notice that when we make a new label, we use a colon ":", but when we use the label in the RESTORE statement, we drop the colon.
Loading a Database
DATA statements are perfect for loading a database. Here's a new version of the database example using DATA statements this time.
DATA "Joe Blow", "1-310-555-1212"
DATA "Jack Sprat", "1-340-555-6545"
DATA "Carol Christmas", "1-350-555-2421"
TYPE FriendType
FullName AS STRING * 20
PhoneNumber AS STRING * 14
END TYPE
' The database
DIM Friends(2) AS FriendType
' Read in the database from the DATA statements
FOR I = 0 TO 2
READ Friends(I).FullName, Friends(I).PhoneNumber
NEXT I
' Print out the entire database
FOR I = 0 TO 2
PRINT Friends(I).FullName; ": "; Friends(I).PhoneNumber
NEXT I
________________________________________
- Reading and Writing Files
Up to now, our programs have depended on us, the programmer, to give them data to work with. This wouldn't work very well for a phone book program. The user should be the one to fill in the names and phone numbers. QBASIC will let us get information from the user with INPUT. But when the program ends, that information is gone.
Writing to a file
The solution to this problem is to let the user enter their information, then the program will store that information in a file on the hard disk. QBASIC offers a number of ways to do this. Try this:
INPUT "Enter your name: ", Name$
OPEN "testfile.txt" FOR OUTPUT AS #1
WRITE #1, Name$
CLOSE #1
When you run that program, and enter your name, it will place your name in a file on the hard disk called "testfile.txt". You can use Notepad to find it and make sure your name is there. You might need to figure out where QBASIC put the file. That can be a little tricky. If you exit QBASIC, and from the DOS prompt enter this:
type testfile.txt
You should see your name, or whatever you entered. The "type" command at the DOS prompt copies the contents of a file to the screen. You could also try this:
notepad testfile.txt
That should bring up notepad with your file. When you are working with files, it is a good idea to know how to bring them up in notepad. This way you can look at them to see if they contain what you expected.
OPEN, WRITE, and CLOSE
There are three statements, OPEN, WRITE, and CLOSE that are needed to write information to a file. The OPEN statement tells QBASIC three things:
1. The name of the file (testfile.txt)
2. Whether we want to write to the file (OUTPUT) or read from the file (INPUT)
3. The file number (#1 in this example)
Once the file is opened, we will use the file number to let QBASIC know which file we want to write to. You could have many files open at the same time, so the file number lets QBASIC know which file you want to work with.
The WRITE statement tells QBASIC which file we want to write to (#1), and what we want to write (Name$). It is very much like a PRINT statement, but instead of sending the information to the screen, WRITE sends the information to a file.
Finally, we need to CLOSE the file, to let QBASIC know that we are done. Otherwise, QBASIC might not write anything to the file at all. The CLOSE statement only needs to know which file you want to close, so it only requires the file number.
Reading from a file
The following program will get the name and print it on the screen:
OPEN "testfile.txt" FOR INPUT AS #1
INPUT #1, Name$
CLOSE #1
PRINT Name$
There are three main things that are different in this program if you compare it to the previous program.
1. The OPEN statement uses "INPUT" instead of "OUTPUT". This tells QBASIC that we plan to get data from the file.
2. The INPUT statement, which you've seen before, is used to read from a file. The #1 tells it that we want to read from file #1. When we've used INPUT in other programs, there was no #1. Without a file number, INPUT gets information from the keyboard. With a file number, it gets information from a file.
3. Instead of getting something from the user at the beginning of the program, we display what was read from the file at the end with a good ol' PRINT statement.
One thing that hasn't changed at all is the CLOSE statement. We CLOSE file #1 so that QBASIC knows we are done with it. While we probably won't lose any data if we don't CLOSE in this case, it is still a good thing to do. QBASIC can only open so many files, so if you leave some open, you might not be able to open any more.
Logging
Sometimes it can be very useful to write to a file while a program is running so that you can look at what happened later. This is called "logging". We can use the "APPEND" option in the OPEN statement to open a file and simply keep adding to the end of it.
OPEN "logfile.txt" FOR APPEND AS #1
PRINT #1, "Program Run: "; TIME$
CLOSE #1
CLS
INPUT "What is your name"; Name$
PRINT "Hello, "; Name$
OPEN "logfile.txt" FOR APPEND AS #1
PRINT #1, "Program Stopped: "; TIME$
CLOSE #1
We've logged two things in this program, the program's start time, and it's end time. Run the program a few times, then exit QBASIC and type:
notepad logfile.txt
That will show you what is in your log.
Input Files
Ideas: Fortune Teller using a text file as input. This would combine file input with arrays.
Keeping Track of Things
Let's say we want our program to remember who it is registered to. We also want it to count how many times it has been run. We could try something like this:
CLS
INPUT "Enter your name to register this program: ", Name$
PRINT "Thank you, "; Name$
RunCount = RunCount + 1
PRINT "This program is registered to: "; Name$
PRINT "This program has been run"; RunCount; "times."
PRINT "We hope you have enjoyed it."
But that doesn't work. Why? Because QBASIC can't remember the value of the variables Name$ and RunCount from one run of the program to the next.
To fix this, we need to use a file. We can read the file before the program starts, and write the file back out when the program is finished. We will save the user's name and the number of times the program has been run in this file.
The code to do this is a bit more complex than what we've done so far. This is because QBASIC handles file errors in a strange way. Our program must handle one file error. The first time it is run, there will be no registration file for it to read. So the OPEN will fail. We have to handle this, or our program won't work.
' If there are any problems, QBASIC will jump to ErrorHandler below.
ON ERROR GOTO ErrorHandler
' This is the error code that is filled in by the error handler
DIM ErrorCode AS INTEGER
CLS
' Always reset this before doing something you want to check
ErrorCode = 0
' Try to get the name and run count from the file
OPEN "register.txt" FOR INPUT AS #1
' If the file wasn't found
IF ErrorCode = 53 THEN
' Get the name from the user
INPUT "Enter your name to register this program: ", Name$
PRINT "Thank you, "; Name$
' And set the run count to 0
RunCount = 0
ELSE
' Get the user's name and the run count from the file
INPUT #1, Name$, RunCount
CLOSE #1
END IF
RunCount = RunCount + 1
PRINT "This program is registered to: "; Name$
PRINT "This program has been run"; RunCount; "times."
PRINT "We hope you have enjoyed it."
' Save the name and run count for the next run
OPEN "register.txt" FOR OUTPUT AS #1
WRITE #1, Name$, RunCount
CLOSE #1
' This END prevents us from running the error handler at the
' end of the program. It causes the program to stop, just
' like pressing the Break key.
END
' QBASIC will jump here if an error occurs
ErrorHandler:
' We have to move the error code into a variable or we won't
' see it because ERR is set to zero after the handler is done.
ErrorCode = ERR
RESUME NEXT
Handling File Errors
"ON ERROR GOTO ErrorHandler" tells QBASIC that if there is a problem, the program should immediately jump to "ErrorHandler:" which you will see near the end of the program. There we can get the error code which is in a QBASIC variable called "ERR" and copy it to our own variable "ErrorCode". If we don't do this, we will lose the error code stored in ERR. RESUME NEXT tells QBASIC to continue from where the error occurred.
I try very hard to avoid using GOTO in my programs. Programs that use GOTO can be very hard to understand. Unfortunately, in this case, QBASIC leaves us with no alternative. We have to use a GOTO. So, I've tried to come up with the simplest solution that keeps the code from being too hard to follow. With this little error handler in place, we can simply assume that ErrorCode will contain the error number when something goes wrong. Just don't forget to reset it or you will be looking at old errors!
Binary I/O
What is it?
Binary I/O is best explained in terms of numbers. In a computer, everything is numbers. Computers don't know about letters. The only reason computers can store text is because that text is converted to numbers using a code called ASCII. See http://en.wikipedia.org/wiki/Ascii
There are two ways to write a number to a file.
The first way is to take the number, convert it to ASCII codes, then write those code numbers to the file. Here's an example:
• Start with the number 6023
• Convert it to a string: "6023"
• Convert that to ASCII: 54 48 50 51
• Write those numbers to the file.
This is what PRINT #1 does. You can think of this as "Text I/O", although that term is used in other programming languages to mean other things, so be careful.
The other way is to skip the conversion to ASCII and just write the number to the file.
• Start with the number 6023.
• Write it to the file.
This is referred to as binary I/O. QBASIC offers some special statements and functions to support doing binary I/O.
How to do it in QBASIC.
What is the difference? Unformatted, unreadable.
Why is it a good thing? Small, unreadable to prying eyes, fast.
Sample: Write out a few numbers and strings. Examine with notepad. Read them back in.
Random I/O
Up to this point we have been using what is called "Sequential I/O". Sequential means "one after another". I/O stands for Input/Output. When we write the user's name and the run count to the file, we write them one after another. This is sequential output. When we read the name and run count, we read them one after another. Name first, then run count. This is sequential input. All together, this adds up to Sequential Input and Output, or Sequential I/O.
Random I/O lets you read and write data to any part of a file in any order you want. It is very useful when you have very large files, and you don't have enough time or memory to read everything in the file sequentially (one after another). Random I/O lets you jump right to the data you want in a file, and read or write it.
Even in very large and complex programs, Random I/O is rarely used due to its complexity. Imagine if the program has a bug and it writes to the wrong location in the file. The file could be destroyed because of this. We won't cover Random I/O here. But, if you need it, it's in QBASIC.
________________________________________
- Sample Programs
Read the Manual
You've learned a lot. If you've made it through this far, and you are still having fun, then it's time to make up some of your own programs. QBASIC's help is what you should read through whenever you are curious about everything else QBASIC can do. It can do a lot more than what I've shown you in this book.
Some of the samples that follow may do things that you haven't seen mentioned in the book. See if you can find out what these new things are by looking them up in the help that comes with QBASIC.
Number Guesser
In this game, the computer picks a number between 1 and 10. You have to try and guess the number.
CLS
RANDOMIZE TIMER
PRINT "Welcome to Number Guesser"
PRINT "I'm thinking of a number between 1 and 10."
Number = INT(RND * 10 + 1)
DO
INPUT "What is your guess? ", Guess
IF Guess = Number THEN
PRINT "Correct!"
EXIT DO
ELSE
PRINT "Try again"
END IF
LOOP
________________________________________________________________________________________
________________________________________________________________________________________
