There is a board in the forum (link on the top) which we set up to discuss these C Tutorials. Once you register you can post questions or discussion items there.

/* Draw a scaled car on the console or terminal window.
Takes input value of length of the arm of the X.
C Tutorials for the home ed student
Ron R.
September 2005

Consider an car which is 6 characters high and 19 characters wide

row column
0 1234567890123456789
1 *********
2 * * *
3 ******************
4 * *
5 *** ******** ****
6 ** **

Note that:
the top is 2 rows, the body is 3 rows and the wheels are 1 row
the length is 19 characters
therefore we can scale this by multiplying the dimensions by 1,2,3 or 4
and it will still fit on the screen
normally the front and rear windows are sloped
and the wheels are round
the remainder will be calculated as necessary
*/

#include

int main()
{
int scale; // entered scale of car and height of wheels
int top; // height of top
int body; // height of body
int row,col; // current row and column in printing
int length; // overall length of car
int pad; // how much to pad left of car
int topleft; // top left of top of car
int topright; // top right of top of car
int hood; // left of hood of car
int doorpost; // location of door post
int bottomleft; // left of left wheel
int bottomright; // left of right wheel
int wheel; // width of wheel

do
{
printf(“Enter the scale of the car (1-4, 0=Exit): “);
scanf(“%i”,&scale);
} while(scale < 0 || scale > 4);
// only draw if they have not entered a 0
if(scale > 0)
{
// this is a good example of the use of a switch
switch(scale)
{
case 1:
pad = 30;
break;
case 2:
pad = 21;
break;
case 3:
pad = 12;
break;
case 4:
pad = 2;
break;
}
// give it some spacing
printf(“\n”);
// calculate some values for car
hood = top = scale * 2;
bottomleft = body = scale * 3;
length = scale * 19;
topleft = scale * 6;
topright = scale * 14;
doorpost = scale * 10;
bottomright = scale * 13;
wheel = scale * 3 – 1;
// loop through each row of top
for(row=1;row< =top;row++)
{
// pad the row to center the car
for(col=1;col<=pad;col++)
{
printf(" ");
}
// this will be repeated for each row
for(col=1;col<=length;col++)
{
// if roof
if(row == 1)
{ // if between topleft and topright
if(col >= topleft && col < = topright)
{
printf("*");
}
else
{
printf(" ");
}
}
else
{
if((row + col) == (topleft + 1) || // front window
(topright + row) == (col + 1) || // rear window
col == doorpost)
{
printf("*");
}
else
{
printf(" ");
}
}
}
// goto a new line
printf("\n");
}
// loop through each row of body
for(row=1;row<=body;row++)
{
// pad the row to center the car
for(col=1;col<=pad;col++)
{
printf(" ");
}
// this will be repeated for each row
for(col=1;col<=length;col++)
{
if(row == 1) // top line of body
{
if(col >= hood) // round hood a bit
{
printf(“*”);
}
else
{
printf(” “);
}
}
else if(row == body) // bottom line of body
{
if(col < = bottomleft || // left of front wheel
(col > (bottomleft + wheel) &&
col < = bottomright) || // between wheels
col > (bottomright + wheel)) // right of rear wheel
{
printf(“*”);
}
else
{
printf(” “);
}
}
else if(row < = (((scale - 1) * 2) + 1)) // sloped front
{
if((col + row) == (hood + 1) || // front
col == length) // back
{
printf("*");
}
else
{
printf(" ");
}
}
else // square front
{
if(col == 1 || // front
col == length) // back
{
printf("*");
}
else
{
printf(" ");
}
}
}
// goto a new line
printf("\n");
}
// loop through each row of wheels
for(row=1;row<=scale;row++)
{
// pad the row to center the car
for(col=1;col<=pad;col++)
{
printf(" ");
}
// this will be repeated for each row
for(col=1;col<=length;col++)
{
if(row == scale) // bottom of wheel
{
if((col >= (bottomleft + scale) && // front wheel
col < = (bottomleft + wheel - scale + 1)) ||
(col >= (bottomright + scale) && // rear wheel
col <= (bottomright + wheel - scale + 1)))
{
printf("*");
}
else
{
printf(" ");
}
}
else // slope of wheel
{
if(col == (bottomleft + row) || // front left
(col + row) == (bottomleft + wheel + 1) || // front right
col == (bottomright + row) || // rear left
(col + row) == (bottomright + wheel + 1)) // rear right
{
printf("*");
}
else
{
printf(" ");
}
}
}
// goto a new line
printf("\n");
}
}
return 0;
}

/* Draw a scaled Y on the console or terminal window.
Takes input value of length of the arms of the Y.
C Tutorials for the home ed student
Ron R.
August 2005

Consider an Y which is 9 characters high and 9 characters wide

row column
0 123456789
1 \ /
2 \ /
3 \ /
4 \ /
5 Y
6 |
7 |
8 |
9 |

Note that:
the \ character appears where row = column
the / character appears where (row + column) = (2 * (arm + 1))
the Y appears where column = (arm + 1)
the | appears for arm length rows where column = (arm + 1)

therefore we can divide the character into 2 sections:
the first is the upper arms
the second is the center and lower arm
*/

#include

int main()
{
int arm; // length of arm
int width; // overall width (and height) of X
int row; // current row in printing
int col; // current column in printing

/* this is a good example of the use of a do/while
we want to collect the value from the user before
we test to see if it is within an acceptable range
so that the drawn x will fit in the screen
*/
do
{
printf(“Enter the length of the arm of the X (1-12, 0=Exit): “);
scanf(“%i”,&arm);
} while(arm < 0 || arm > 12);
// only draw if they have not entered a 0
if(arm > 0)
{
width = 2 * (arm + 1);
// give it some spacing
printf(“\n”);

// loop through each row of the top
for(row=1;row<=arm;row++)
{
// this will be repeated for each row
for(col=1;col {
// check for back diagonal
if(row == col)
{
printf("\\");
}
// check for forward diagonal
else if((row + col) == width)
{
printf("/");
}
// print an empty space
else
{
printf(" "); // try replacing the space with a period
}
}
// goto a new line
printf("\n");
}
// now draw leg (including centre) of Y
// change initial value to 0 to get extra row for center Y
for(row=0;row<=arm;row++)
{
// this will be repeated for each row
// change initial value to 0 to get extra column
for(col=0;col<=arm;col++)
{
// time to print a character?
if(col == arm)
{
if(row == 0)
{
printf("Y");
}
else
{
printf("|");
}
}
// print an empty space
else
{
printf(" "); // try replacing the space with a period
}
}
// goto a new line
printf("\n");
}

}
return 0;
}

As far as I know, all of the students I had in college came from public school. Some had attended other colleges and/or universities. So far in these tutorials, I have covered about the first third of the content/language of a typical first level C programming course. The big difference between these tutorials and my typical college class is that, they had programming assignments to do, which they handed in and I marked. To some degree, the format of all my courses forced the students to do at least some programming.

Based on this background, it is really important that you see the difference between these tutorials and some of the other subjects that you might study for ‘school’. For example, if you study history, you can do quite well on a test solely because you have a good memory. Programming does not work like that.

Programming is something you have to do to learn. The example I frequently used for this was riding a bike. You don’t learn to ride a bike by having someone else explain what all the parts of the bike are, how to ride it, or by watching someone else ride one. Because you have to train the part of your brain that controls your muscles, you have to get on the bike and ride it. Tail whips and back flips take lots and lots of practice.

In the case of programming, you have to train your mind to think in a way that is at least a little different from anything you have likely done before. In a way, it is very much like playing a game. What I found most difficult for students to grasp was the reality that they were the only intelligence in the equation. When you use your computer, you are looking at a lot of things that look pretty complicated and give the computer the appearance of being smart/intuitive. But every bit of that has been design and developed by other people. When it comes down to it, every computer is something that can do a lot of very simply operations at very high speed. It is the programmer’s job to organize those simple operations to get the computer to do something they want.

So, the next few tutorials will be programs using the things I have already talked about. In each, I’ll explain the logic I used to arrive at the program that is implemented in the tutorial. It will be up to you to try similar things to exercise your programming muscles. Here is the first one:

/* Draw a scaled X on the console or terminal window.
Takes input value of length of the arm of the X.
C Tutorials for the home ed student
Ron R.
August 2005

Consider an X which is 9 characters high and 9 characters wide

row column
0 123456789
1 \ /
2 \ /
3 \ /
4 \ /
5 X
6 / \
7 / \
8 / \
9 / \

Note that:
the \ character appears where row = column
the / character appears where (row + column) = (2 * (arm + 1))
the X appears where row = column and (row + column) = (2 * (arm + 1))

*/

#include

int main()
{

int arm; // length of arm
int width; // overall width (and height) of X
int row; // current row in printing
int col; // current column in printing

/* this is a good example of the use of a do/while
we want to collect the value from the user before
we test to see if it is within an acceptable range
so that the drawn x will fit in the screen
*/
do
{

printf(“Enter the length of the arm of the X (1-12, 0=Exit): “);
scanf(“%i”,&arm);

} while(arm < 0 || arm > 12);
// only draw if they have not entered a 0
if(arm > 0)
{

width = 2 * (arm + 1);
// give it some spacing
printf(“\n”);

// loop through each row
for(row=1;row {

// this will be repeated for each row
for(col=1;col {
// check for centre
if(row == col && (row + col) == width)
{

printf("X");

}
// check for back diagonal
else if(row == col)
{

printf("\\");

}
// check for forward diagonal
else if((row + col) == width)
{

printf("/");

}
// print an empty space
else
{

printf(" "); // try replacing the space with a period

}
}

// goto a new line
printf("\n");
}

}

return 0;

}

> - greater than – x > y means compare x to y and if x is greater than y then return true otherwise return false

>= – greater than or equal to – works the same as > except if the values are equal then it also returns true

< – less than – works the same as > except if x is less than y then it returns true

<= – less than or equal to – works the same as < except if the values are equal then it also returns true

== – equal to – returns true if the values are the same otherwise returns false

!= – not equal to – opposite of equal to

! – not – changes false to true and true to false – eg. !(x > y) would be the same as <= y. This does have uses, I promise

&& – and – requires that both the value on its left and the value on its right be true to return a true – eg. (x > y) && (x > z) means x must be greater than both y and z for this to evaluate to true

|| – or (2 pipe symbols) – requires that either the value on its left or the value on its right be true to return a true – eg. (x > y) || (x > z) means x must be greater than either y or z for this to evaluate to true

In the previous post, I used some arithematic operators. Here is a longer list:

= – assignment operator – performs all the calculations to the right of it to produce a single value and then assigns that value to the variable to the left of it. eg. x = y + z adds y and z and stores the result in x. The existing value that was in x is replaced.

+ – add
- – subtract
* – multiply
/ – divide
% – modulus – this is an integer calculation. It produces the remainder from integer division. eg. 3 % 3 is 0, 4 % 3 is 1, and 5 % 3  is 2

+= – add assign – x += y adds x and y and stores the results in x. The remainder of the assigns work the same way
-= – subtract  assign
*= – multiply assign
/= – divide assign
%= – modulus assign

++ – increment – can be used in 2 ways: preincrement ++x or postincrement x++. Increment increases the value stored in a variable by 1. The difference between pre and post increment is whether the increment is performed before or after the variable is used in the current line of code.

So, x = y + ++z increases z by 1 and then adds y and z and stores the result in x.
x = y + z++ adds y and z and stores the result in x and then adds increases z by 1.

– – decrement – works just like increment except that it decreases the value in the variable by 1.

Thats not all the operators, but we can do a lot of things with these. I’ll introduce other operators when I use them in a sample.

char thePage[20480];

If we wanted to look at the first character in the page we would use this in our program:

thePage[0]
and the last character in the array would be
thePage[20479]

It is important to remember that C uses a zero based index for arrays. The last element of the array is always indexed at 1 less than the size of the array. The next post will be about program control. With it I will do another example program to demonstrate how arrays are used and why they are so useful. Once you start programming, you will find that you frequently use arrays.

if(condition to evaluate)
{
… one or more statements
}
else // can also be else if (condition to evaluate)
{
… one or more statements
}

and

for(init;condition to evaluate;execute on loop)
{
… one or more statements
}

In both the if and the for statement is condition to evaluate which consists of the logical operations described in this post. The code that is between the first set of braces after the if are executed if the logical operation produces a true result. If there is an else associated with the if then code between the set of braces after the else are executed.

In C, for is a looping (or iterating) statement. In the for statement, the init is code that is executed before the loop begins. The code between the braces is executed as 1 iteration of the loop. At the end of each iteration, the code in execute on loop is executed. Then the for statement evaluates condition to evaluate and if it evaluates to true then it re-executes the loop. This continues until the condition to evaluate evaluates to false.

Here is the sample code for this tutorial. It is commented as well.

#include <stdio.h>

/* Sample Program for C Tutorials for the home ed student.
Demonstrating the use of an integer array and a character
array.
Ron R.
July 2005
*/

int main()
{

// some variables for iteration
int i,j;
// some variables to track integer values
int max,min,sum;
// preassign values to integer array
int example[10] = {45,22,67,987,423,11,45,76,16,91};
// space for an extra character has to be left on the end
char sentence[13] = “Hello World!”;
// show the sentence one character at a time
for(i=0;i<13;i++)
{

/* %c = print a character
then printf needs a piece of data for each control string
*/
printf(“%c “,sentence[i]);

}
/* print integer values and calculate values
the next statement is called a compound assignment
sum, min, max will all be set to the value in example[0]
*/
sum = min = max = example[0];

printf(“\n”); // some spacing

for(j=0;j<10;j++)
{

// print it – %i = print an integer
printf(“%i:%i\n”,j,example[j]);
/* if this is not the first element in the array we have to do some
other processing
*/
if(j != 0)
{

// add to sum
sum += example[j];
// if its smaller than current min then replace
if(example[j] < min)
{

min = example[j];

}
// it will only be bigger when it is not smaller than min
else if (example[j] > max)
{

max = example[j];

}
}
}
// print results
printf(“smallest #: %i\n”,min);
printf(“largest #: %i\n”,max);
printf(“sum of #s: %i\n”,sum);
return 0;
}

Try it. Then change the numbers and see what happens. Put in a different sentence.

In addition to if/else if/else there is a second series of conditional execution statements.

switch(variable to compare)
{
case literal:
… one or more statements
break;
case literal:
… one or more statements
break;
default:
… one or more statements
break;
}

There really isn’t a good use for the switch/case/default structure in this tutorial’s example program. An instance where this is used is when you are offering the user a menu of choices. In that case, the variable to compare is the data that your program collected as the user’s choice from the menu. Each literal would be an option from the menu. In the switch/case/default, the default is optional. The default is the code that gets executed if none of literals in the cases are the same as the variable to compare.

To illustrate this, consider the following menu:

Inventory Management

A – Add an Item
C – Change an Item’s Information
D – Delete an Item
P – Print All Current Items
Q – Quit Program

The switch/case/default might look like this:

switch(choice) // char choice defined above
{

case ‘A’:<

…code to add an item
break; // ends the switch statement and moves execution to closing brace

case ‘C’:

…code to change an item
break;

case ‘D’:

…code to delete an item
break;

case ‘P’:

…code to print items
break;

case ‘Q’:

…code to tell the program to quit
break;

default:

printf(“Not a menu option\n”); // show error message
break;

}

And there are also alternate looping structures.

while(condition to evaluate)
{
… one or more statements
}

or

do
{
… one or more statements
} while(condition to evaluate)

In both the while and the do/while statement is condition to evaluate which has the same application as it did in Part 1. Both the while and the the do/while are looping (or iterating) statements. The code between the braces is executed as 1 iteration of the loop. Then the while and the do/while statement evaluates condition to evaluate and if it evaluates to true then it re-executes the loop. This continues until the condition to evaluate evaluates to false.

The only difference between the while and the do/while is that the while test the condition before the first iteration of the loop but the do/while does not. So, if the condition is false on the first test a while does not execute but a do/while does.

Here is the sample code for this tutorial. It is commented as well.

#include <stdio.h>

/* Sample Program for C Tutorials for the home ed student.
Demonstrating the use of an integer array and a character
array.
Ron R.
August 2005
*/

int main()
{

// some variables for iteration
int i,j;
// some variables to track integer values
int max,min,sum;
// preassign values to integer array
int example[10] = {45,22,67,987,423,11,45,76,16,91};
// space for an extra character has to be left on the end
char sentence[13] = “Hello World!”;
// show the sentence one character at a time
i=0; // set initial value for loop
while(i<13)
{

/* %c = print a character
then printf needs a piece of data for each control string
*/
printf(“%c “,sentence[i]);
i++; // increment counter

}
/* print integer values and calculate values
the next statement is called a compound assignment
sum, min, max will all be set to the value in example[0]
*/
sum = min = max = example[0];

printf(“\n”); // some spacing

j=0;
do
{

// print it – %i = print an integer
printf(“%i:%i\n”,j,example[j]);
/* if this is not the first element in the array we have to do some
other processing
*/
if(j != 0)
{

// add to sum
sum += example[j];
// if its smaller than current min then replace
if(example[j] < min)
{

min = example[j];

}
// it will only be bigger when it is not smaller than min
else if (example[j] > max)
{

max = example[j];

}
}
j++;
} while(j<10)
// print results
printf(“smallest #: %i\n”,min);
printf(“largest #: %i\n”,max);
printf(“sum of #s: %i\n”,sum);
return 0;
}

]]> http://atypicalhomeschool.net/tutorials/conditions-iterations-part-2-of-2/feed/ 0 http://atypicalhomeschool.net/tutorials/datatypes-comments-example/ http://atypicalhomeschool.net/tutorials/datatypes-comments-example/#comments Mon, 18 Jul 2005 12:49:30 +0000 Ron http://atypicalhomeschool.net/wp/tutorials/datatypes-comments-example/ In this code sample, I’ve placed lots of comments. To see how well I’ve done at commenting, I’ll leave it to you to ask any questions in the forums.

#include

/* a simple calculator
July 19, 2005
Ron R.
C Tutorials for the home ed student
*/
int main()
{

// declare dataspace
int first; // first integer
int second; // second integer
/* note you can declare 2 variable of the same type
in the same declaration */
float firstf,secondf; // first and second float values

// now get some values from the keyboard
printf(“\nEnter a whole number: “);
// scanf() scans formatted input
scanf(“%i”,&first); // %i is the formatting for an integer
printf(“Enter a second whole number: “);
scanf(“%i”,&second); // store the value in the variable second
// now decimals
printf(“\nEnter 2 decimal numbers separated by a space: “);
/* %f is the formatting for an floating point
you can also scan for more than 1 value at a time
*/
scanf(“%f %f”,&firstf,&secondf);

// show some math
printf(“\n%i + %i = %i\n”,first,second,first + second);
printf(“%i – %i = %i\n”,first,second,first – second);
printf(“%i x %i = %i\n”,first,second,first * second);
printf(“\n%f + %f = %f\n”,firstf,secondf,firstf + secondf);
printf(“%f – %f = %f\n”,firstf,secondf,firstf – secondf);
printf(“%f * %f = %f\n”,firstf,secondf,firstf * secondf);

return 0;

}

Give it a try and see what happens with different ranges of values. Also, try giving it some bogus data like letters, etc.

]]> http://atypicalhomeschool.net/tutorials/datatypes-comments-example/feed/ 0 http://atypicalhomeschool.net/tutorials/datatypes/ http://atypicalhomeschool.net/tutorials/datatypes/#comments Sat, 16 Jul 2005 12:44:55 +0000 Ron http://atypicalhomeschool.net/wp/tutorials/datatypes/ In the The Traditional First Program I talked about the main() function returning an integer to the operating system. int is a datatype. In C, there are a few basic datatypes. Before I talk about those, I’ll explain a bit about computers and memory.

The smallest piece of memory in a computer is called a bit. Bit stands for binary digit. In the binary number system there are only two numbers: 0 and 1. So, a bit is like a switch that the computer can turn on and off. The next relevant memory size is called a byte. In a sense, this is really the basic size that computer programs work with. A byte is 8 bits and can contain 256 different values.

From a byte we get kilobyte (KB), megabyte (MB), gigabyte (GB), etc. A KB is 1024 bytes. A MB is 1024 KB (1,048,576 bytes). A GB is 1024 MB (1,073,741,824 bytes).

The basic datatypes in C are as follows with the number of bytes used in ():

char (1) a single character
short (2) a whole number between -32768 and 32767
int (2 or 4 depending on processor – on intel and similar processors it is 4)
long (4) a whole number between -2,097,154 and 2,097,153
float (4 on intel and similar processors) a floating point decimal value where min and max values depend on processor
double (8) a double precision float. A double will hold a wider range of values than a float but it’s primary use is to provide more precise calculations.

Also, all datatypes except the float and double can have the keyword unsigned placed in front of them. What this means is that they only hold positive numbers. For example, and unsigned short can have values between 0 and 65,535.

If I want to create an integer in a program to use to store a whole number value of a high score, I would do it like this:

int highscore;

If I wanted to give it a starting value of 0, I would do this:

int highscore=0;

You’ll see some examples of datatype usage in the next tutorial.

]]> http://atypicalhomeschool.net/tutorials/datatypes/feed/ 0 http://atypicalhomeschool.net/tutorials/comments/ http://atypicalhomeschool.net/tutorials/comments/#comments Tue, 12 Jul 2005 12:44:15 +0000 Ron http://atypicalhomeschool.net/wp/tutorials/comments/ Every programming language I’ve worked with allowed the programmer to add comments to the program. Comments are essentially programmer notes which the compiler ignores. In the small programs I’ve had here so far comments haven’t really been necessary. However, when you have a program that has 10,000 lines of code and you haven’t looked at it in a couple years, comments come in handy. A second instance where comments are handy is when you are trying to make changes to programs someone else wrote. I’ve modified programs written by other people. Some were well commented, others not. If I had not already been convinced of the value of comments, working with those poorly commented programs would have changed my mind.

In C, comments can be added to a program in 2 ways. The first way is with a //. When the compiler sees // it ignores the rest of the line. So, you can add a comment that is a full line in the program by starting the line with //. But you can also use the // after the line of code like this:

printf(“Hello World!\n”); // Say Hello

The compiler ignores the Say Hello. The // does not need to have a space before or after it.

The second type of comment is a multiline comment. Multiline comments begin with /* and end with */. The compiler ignores everything between the comments. The /* and the */ do not need to be on separate lines, but can be any number of lines apart. There are sensible restrictions to the use of /* and */. For example

printf(“Hello /* Say Hello */World\n”);
will print
Hello /* Say Hello */World

printf/* Say Hello */(“Hello World\n”);
will give an error

printf(“Hello World\n”)/* Say Hello */;
will print
Hello World

printf(“Hello World\n”)
/*
Say Hello
*/;
will print
Hello World

]]> http://atypicalhomeschool.net/tutorials/comments/feed/ 0