Programming in C

Introduction

On the Macintosh, there is a Run menu item in Think C, or you can build an application, save it, exit Think C, and double click on the application to run it. As with other systems, you must recompile and save the application after you edit the program.

-- initial part of template.c omitted from this listing --

/* these declarations are necessary to keep most
   compilers from complaining: */
void up();
void down();

void mainscore()
{
    while (askbool("Type RETURN to play, or N RETURN to quit",
                   true)) {
        up();
        down();
        up();
        note(60, 100);
    }
}

void up()
{
    note(60, 20);
    note(62, 20);
    note(64, 20);
    note(65, 20);
}

void down()
{
    note(67, 20);
    note(65, 20);
    note(64, 20);
    note(62, 20);
}

-- remainder of template.c omitted from this listing --

Notice the appearance of up and down near the beginning of the file. These tell the compiler that up and down are procedures that will be defined later. Notice the semicolons in these lines.

When this program is run, the computer will do what mainscore says to do. The first call is to up, so the computer finds the definition of up and does what up says to do. In this case, up plays four notes (C, D, E, F). Now that up is finished, mainscore continues by calling down, which in turn plays (G, F, E, D). When down returns, mainscore continues with another call to up, and again up will play C, D, E, F. Finally, up returns and mainscore plays a C. At this point the mainscore program is finished.

void mainscore()
{
    repeat(i, 5)
	note(60, 30);
	note(72, 30);
    endrep
}

repeat(counter, howmany) phrase endrep

The phrase could just as well have been calls to other procedures. The next example uses repeat to play C4 D4 E4 F4 three times, using the up procedure used earlier.

void up();

void mainscore()
{
    repeat(i, 3)
	up();
    endrep
}

void up()
{
    note(60, 20);
    note(62, 20);
    note(64, 20);
    note(65, 20);
}

void mainscore()
{
    repeat(i, 2)
	note(72, 30);
	note(71, 15);
	note(69, 15);
	note(67, 15);
	note(65, 15);
	note(64, 15);
	if (i == 1) {
	    note(65, 15);
	    note(67, 120);
	} else {
	    note(62, 15);
	    note(60, 120);
	}
    endrep
}

if (condition) { phrase1 } else { phrase2 }

mainscore()
{
    repeat(i, 3)
	p1();
	if (i == 2) {
	    p2();
	} else {
	}
	p3();
    endrep
}

mainscore()
{
    repeat(i, 3)
	p1();
	if (i == 2) {
	    p2();
	}
	p3();
    endrep
}

void newup(int dur);

void mainscore()
{
    newup(25);
    newup(50);
}

void newup(int dur)
{
    note(60, dur);
    note(62, dur);
    note(64, dur);
    note(65, dur);
}

After the fourth note is played, the computer returns to mainscore, where the next thing in the sequence is another call to newup. But this time, the parameter is 50. The computer goes through the same steps as before: it finds the definition of newup, associates the value of 50 with dur, and substitutes 50 for dur throughout the definition of newup. The result is that the four notes (C4 D4 E4 F4) are now played with durations of 50, or one half second.

Parameters may be named with any string of letters, just like procedures. It is a good idea to use mnemonic names, that is, names that remind you of their purpose. It makes no difference to the computer, but when you start writing large programs, you will find that it is important to make programs readable and understandable.

Notice that parameters in the procedure definition are preceded by the word int. This declares the type of the parameter to be an integer value. For now, we will use nothing but integers, so all parameter declarations should be of the form ``int parametername.''

Important: When you use parameters, the number of parameters in the definition must match the number of parameters in the call. The order of parameters in the call determines which parameter gets which value. If you use a procedure (e.g. in mainscore) before defining it, you must declare the procedure as illustrated in the top line of this example. The declaration is similar to the definition, but the entire body of the definition delineated by braces is replaced by a semicolon. The parameters in the declaration must match the parameters in the full definition.

minor(int tonic, int duration)
{
    pnote(tonic, duration);
    pnote(tonic + 3, duration);
    note(tonic + 7, duration);
}