LEARNING C

For Beginners

By:-
By:-
Alexander
Learning “C”

Acknowledgement

Hello, this is Alexander. I am writing this for those people

who want to learn how to program in C, but are scared of it.
It is scary, but it is not hard, well, it is hard, but it is a great
feeling making a game, or a program of no value, but
knowing that YOU made it. This is for the same reason that I
code my own HTML, even with so many different ways to
use an editor. I like to know that I made it, that I didn't just
say what I wanted. If you want this sense of accomplishment,
then read on.

2
Learning “C”

Overview

1. Introduction to C 4
2. Variable & Stuff 6
3. Loops 8
4. Functions 10
5. Switch Case 13
6. An Introduction to Pointers 15
7. Structures 16
8. Array basics 17
9. Strings 19
10. File I/O (part 1) 22
11. Typecasting 26

3
Learning “C”

LESSON 1
Introduction to C
C is a programming language, of course. It is a programming language of many
different dialects, just like each language that is spoken has many dialects. In C though, they
are not because the 'speakers' live in the North, South, or grew up in some other place, it is
because there are so many compilers. There are about four major ones: Borland C++,
Microsoft Visual C++, Watcom C/386, and DJGPP. You can download DJGPP from one
of the pages connected to my site<http://www.concentric.net/~lallain> and go to the
programming part, or you may have another compiler. I also hope to upload the shareware
version of Turbo C++, which is very similar to Borland C++.

Each of these compilers is a little different. The library functions of one will have all
of ANSI C, the standard, but will have many other functions, or to continue my analogy,
words'. What I am getting at is that some of the stuff I use in this may have to be changed.
If I say #include "malloc.h", you have need to say #include "alloc.h". It is because there are
so many different ways of 'saying' something that sometimes it is hard to communicate, take
a Southerner, and a Northerner. There are often words that get confused.

So, anyway, if you don't have a compiler, I strongly suggest you get one, a simple one
is good enough for my lessons, if they are worthy of that title ;), but get one.

C is a different breed of programming. It has only 33 keywords for DOS, and it has
no keywords to use for output. This means that almost everything is stored in a –header
file-(note: all terms of interest will be set off, but I can't bold). This gives the use of many
functions. But lets see a real program...

#include <iostream.h>
void main()
{
cout<<"HEY, you, I'm alive!";
}
So, that sure looks easy doesn't it. Some of the stuff is weird. Okay, lets break it
down. The -#include- is a preprocessor directive, one that tells the compiler to put all the
stuff in the header file -iostream.h- into our program! This allows me to use some functions
later on.

Also, for most header files you can also use " " to surround the name instead of <>.

The next thing is -void main()- what this is saying is that I am going to have a
function called -main-, and that it returns no value, hence -void-. Then those little -{- braces
are used. They are like the BEGIN and END commands of pascal. basically they are used
to define aresa of some function, or other things we will learn of later.

The next thing is strange. If you have programmed in other languages you might
think that print would be used to display text. It can be, but only if you use a function called

4
Learning “C”

-printf("text goes here");- the cout command can be used to display text but it needs those
strange << things known as insertion operators, basically use it to put text on the screen.

The quotes tell it to put the string as-is on the screen. After that, the little -;- is used
to tell it that that is the end of that function. After, the braces close off the function. Pretty
simple, eh? You can try out this program if you want, just cut and paste it. You should also
know comments. To comment you can either use // which goes to the end of the line, or
you can sue the /* and then */ to make a comment. This is useful. Make sure that you
know how to use it, or you might accidentally comment out a huge chunk of code!

You may be thinking by now that that is fine and good, but what If I want INPUT!?
That is pretty easy. Remember cout<<? Just use cin>>. This simply is used to get input.

#include <iostream.h>
void main()
{
int thisisanumber;
cout<<"Please enter a number:";
cin>>thisisanumber;
cout<<thisisanumber;
}
Okay, what does this do? It does all that you want. It gets input. We know most of
it. The only tough stuff is the cin>> and int. int is basically a keyword that declares a
variable to be an integer. Other types include char, unsigned char, float, long, double. These
define characters, floating point decimals, long integers, and double floats, which go out
farther. These will be used in other programs. The cin>> basically says that it should put in
this is a number whatever the user types in. If it is not a number, the next output will be
kind of weird. Then cout<< uses no quotes to print a variable, this means to print a
variable, if it was as-is in quotes then it would print on the screen a string "thisisanumber".
Don't forget to end functions and declarations with the semi-color(;). Otherwise you will get
an error. They can be very tough to track down too. Now is about the time to learn
something about variables. I have talked about declaring them, but what good is that if you
don't know how to use them. Here goes:
*, -, +, /, =, ==, are all operators used on numbers, these are the simple ones, if you
want ore info on any of this, by the way, e-mail me at lallain@concentric.net. The *
multiplies, the - subtracts, the +( adds, the = assigns the value on the right to the one on the
left: a=3 means that 3 will slide over to be the value stored in a. The == is a comparison
checker.
a=3;
a==3;
This gives the value of 3, and then sees if it has the value of three. This could be use
in an if statement. DONT FORGET TO DECLARE VARIABLES. two otehr things used
as comparisons are the < and > they do what they do in school check to see if it is great
than or less than. To see something like greater or equal too then use >=. This is useful in
some stuff I will covernext week.

5
Learning “C”

LESSON
LESSON 2
Variable & Stuff
Hello, this is Alexander. Since I finally got an email from someone who liked my
previous lesson, I am going to make the second installment. This one will be about
variables, and stuff like 'if' statements.

'IF' is the most important word in programming for many programs. Without it
there is no conditional statement. This means that there can be only one way a program can
execute. It would almost impossible to make a program without this one simple word.

There are many things to understand when using IF statements. First, you must
understand stuff like OR NOT etc. This is the most important, so I will describe how to use
them in C and C++ programming below: (NOTE: ZERO IS FALSE! ONE IS TRUE!)

NOTE: This just says that the program should reverse the value...for example NOT(1)
would be 0. NOT(0) would be 1. NOT (any number but zero) would be 0. In C and C++
NOT is written as - ! - just one simple little character. It is very useful and can save lots of
time.

AND:
This is another important command, and it is used to say that if this AND this is
true... for example (1)AND(0) would come out as 0. (1)AND(1) would come out as 1.
(ANY REAL NUMBER BUT ZERO)AND(0) would be 0. (ANY REAL NUMBER BUT
ZERO)AND(ANY REAL NUMBER BUT ZERO) would be 1. The AND is written as -
&& - in C++. It is just two simple characters.

OR:
Very useful is the OR statement! For example (1)OR(0) would be 1! (0)OR(0)
would be 0. (ANY REAL NUMBER)OR(ANY REAL NUMBER BUT ZERO) would be
1! It is simple, either one can be true and make the whole thing true. The OR is written as -
|| - in C++. It is also two simple characters.

The next thing to learn is to combine them... What is !(1 && 0)? Of course, it
would be 1. This is because 1 && 0 evaluates two 0 and ! 0 equals 1.

Try some of these...they are not hard. If you have questions about them, you can
email me at lallain@concentric.net.

A. !(1 || 0) ANSWER: 0
B. !(1 || 1 && 0) ANSWER: 0 (AND is evaluated before OR)
C. !((1 || 0) && 0) ANSWER: 1 (Parenthesis are useful)

If you find you enjoy this you might want to look more at Boolean Algebra, which is
also very helpful to programmers as it can be good for helping program conditional

6
Learning “C”

statements.

IF is used like this IF(TRUE)

{ DO WHAT IS IN THE BRACKETS }
ELSE is basically ELSE
{ DO WHAT IS IN THE BRACKETS }

Let's look at a simple program for you to try out on your own...

#include <iostream.h> //For output

#include <conio.h> //For getch()

void main() //Most important part of the

program!
{
int age; //Need a variable...
cout<<"Please input your age: "; //Asks for age
cin>>age; //The input is put in age
if(age<100) //If the age is less than 100
{
cout<<"You are pretty young!"; //Just to show you the output
}
if(age==100) //Remember, if the age equals 100 needs two =
{
cout<<"You are old"; //Just to show you it works...
}
if(age>100)
{
cout<<"You are really old"; //Proof that it works for all conditions
}
}

Now, this program did not use && || ! or anything in it. This is because it didn't
need too. I think you should probably be able to make your own if statements with them
without having to worry too much about problems. As always, you can email me at
lallain@concentric.net

7
Learning “C”

LESSON 3
Loops
This is the third installment of the Lessons in C programming tutorials created by
me, Alexander. In this lesson I will cover loops. Loops basically do what it sounds like,
loop. If you have read lesson 2 you should understand some Boolean expressions. If you
do not, you should read it again. When working with loops it is important to understand
truth and false. Maybe you should try doing some truth tables with problems.

There are basically 3 types of loops. FOR, WHILE, DO WHILE Each of them has
their uses. They are all outlined below.

FOR –
FOR loops are the most useful type, I believe. The layout is for(variable
initialization, conditional, incrementing variable) It is very versatile, and the layout can be
changed somewhat. Basically, the variable initialization allows you to either declare a
variable and give it a value, or give a value to another variable. Second, the conditional
statement. What it does is it says that while the conditional is true then it would do what in
is in the body. Third, the incrementing variable section. It does not have to increment a
variable. It can decrement, which is subtracting one, or it can perform various other
manipulations on the variable.

Ex. #include <iostream.h> //We only need one header file

void main() //We always need this

{
//The loop goes while x<100, and x has one
for(int x=0;x<100;x++)/*THE LOOP*/ //added to it every time the
loops
{
cout<<x<<endl; //Outputting x
}
}

This program is a very simple example of a for loop. x is set to zero, while x is less
than 100 do cout<<x<<endl; add 1 to x until the loop ends. Pretty simple to understand,
but it is a very powerful loop, and much better than WHILE and DO WHILE loops.

WHILE –
WHILE loops are very simple, but not as useful as FOR loops. The basic structure
is...WHILE(true) then do whatever is in the body. The truth could be x==1 or while(x!=7)
(x does not equal 7)

Ex. #include <iostream.h> //We only need this header file

8
Learning “C”

void main() //Of course...

{ int x=0; //Don't forget to declare variables
while(x<100) //While x is less than 100 do
{
cout<<x<<endl; //Same output as the above loop
x++; //Adds 1 to x every time it repeats
}
}

This was another pretty simple example, but it is longer than the above FOR loop,
showing why I like for better than while, though while is a very easy loop to use, so if you
are having trouble then you can use it, but try to use for.

DO WHILE –
DO WHILE loops are useful for only things that want to loop at least once.
basically it goes DO { THIS } WHILE(TRUE)

Now, it is your turn to try and do a loop! Make a DO WHILE loop that does what
the above programs do...output 0 to 99! It is not hard, if you have trouble email me at
lallain@concentric.net and I will give you some help... Best of luck :) Check back again for
more programming in C!

9
Learning “C”

LESSON 4
Functions
Now that you have learned all about variables, loops, and if statements it is time to
learn the next thing in programming: Functions. Obviously, you should have a good idea
about what a function is, as you have used ones like cout before. However, this lesson will
be more in detail about not only functions that are already made, but about making your
own, or maybe I will continue this later...

A good way to describe a function is to show its prototype. That means, what it
should return, and what it should take as an argument. For example, the prototype of
getch() is... int getch(void); The int means that it returns an integer, the void means that it
does not take an argument. Now, you may know that getch returns a character! However,
that does not mean it must return a character. The fact that the return type is an integer
makes no difference, because the ASCII character set does not care what type of number it
is, as long as it is a number...don't worry if you don't understand, it is not too important right
now.

What is important is that you understand prototypes. Another prototype is... int
kbhit(void); It returns an integer, and it takes no value. Now that I hope you understand this
then you will be able to use the help files much more easily, and I can go into more about
functions. First, what functions are useful?

There are many useful functions, and often they are hard to find. For Turbo C++
Lite some useful functions include, but are no limited to:

cout<< iostream.h output

cin>> iostream.h input
int getch(void) conio.h get characters
void clrscr(void) conio.h clear screen

Okay, you might be thinking that this is nothing! Four measly functions and you are
right! If there were only a few functions then C/C++ would not be useful. However, a lot
of programs do not need all that many functions. Of course, I suggest that you know ever
function that you can, or at least the name. For this purpose, I will be posting an entire
listing of ever function that I can find out of either help or books I have read. However, for
now, these are probably the most useful functions. After all, if you can clear the screen, get
input and output, and get keypresses, which are useful for stopping the program from
immediately going back to the IDE you can do quite a bit! Believe me, there are a few
specialized, but very useful funcitons, the thing is, you don't really need to use them all the
time! If you have a problem with a function that you need, and I have not put up my list yet,
then email me at lallain@concentric.net, and I will find you what you need!

Anyway, after that long spiel on not needing a lot of functions, I am going to show you how
to make your own functions! Wow, I can do that? Of course, otherwise C/C++ would not

10
Learning “C”

be useful! So, prepare to learn how to make functions.

First let me give you an entire example program. Then we will look at it, and learn how
tomake our own programs.

#include <iostream.h>
#include <conio.h>

int mult(int x, int y);

void main()
{
int x, y;
cout<<"Input a number, and what number to multiply it by";
cin>>x>>y;
cout<<endl<<mult(x, y);
getch();
}

int mult(int x, int y)

{
return x*y;
}

How is this useful...Well, in this program the function is totally useless, and it can
only multiply integers! But this is just to show you how to make functions, after you
understand the basics I hope you will be able to do anything yourself.

What my example does: #includes...basic includes What is int mult(int x, int y); ?
That is a prototype of the function, without it you would not be able to use mult! What is
void main()? You should know that. What is cout<<endl<<mult(x,y); Well, basically it puts
us down a line, and then it outputs what mult returns. More on this later. What is

int mult(int x, int y)

{
return x*y;
}

Well, it is a function! It says that the return type is an integer. When the keywork
return is used it says that the function mult has a value of whatever x*y would be...as it says
return x*y. The two ints that it takes are x and y. So it multiplies them and returns that
value. Then outputs mult(x, y); It is perfectly legal. Perhaps it would help if you think of it
as saying that the function mult has a value of whatever x*y is. This is nottrue really, it just
returns that value, and you can do whatever you want with it, but Ihope it helps.

What can you do? You can make void functions that do anything...

11
Learning “C”

#include <iostream.h>
void function(void);

void main()
{
function();
}

void function(void)
{
cout<<"This is a useless and totally wasteful function";
}

What is does is declare that there is going to be a function, by prototyping, and then
at the bottom the function is defined, and it only does one thing...outputs "This is a useless
and totally wasteful function" However, what if you wanted to do something that took 3
lines four hundred times in different places? Say,

#include <iostream.h>
void function(void);

void main()
{
LOTS OF CODE THAT NEEDS TO OUTPUT Line 1Line 2Line 3
}

void function(void)
{
cout<<"Line 1";
cout<<"Line 2";
cout<<"Line 3";
}

That, aside from the fact that it is a bad example, is where you would use it. When you need
to call something a lot of times, but don't want to cut and paste. Functions are very useful,
and I hope I explained them well enough for you to understand.

12
Learning “C”

LESSON 5
Switch Case
I know that this is probably a let-down, after you learned all about functions, but
switch...case is important to know. After all, it can save space with if statements, and it is
useful. Besides, I couldn't think of anything else that I wanted to write about.

Switch...case looks like this:

switch(expression or variable)
{
case it equals this:
do this;
break;
case it equals this:
do this;
break;
case it equals this:
do this;
break;
...
default
do this
}

So, it works like this. The expression or variable has a value. The case says that if it
has the value of whatever is after this case then do whatever follows the colon. The break
says to break out of the case statements. Break is a keyword that breaks out of the code-
block, surrounded by braces, that it is in. So unless you want it to try the next case then use
break. --You can also use it to break out of loops, something that I failed to mention at the
time.--

What is it used for, the switch...case? Well, let's say that you are writing a menu
program, then you would want to process some input, right? Well, you would want to use a
switch...case statement to process more than one input, because it is more easily used than if
statements.

Here is an example program:

#include <iostream.h>
#include <conio.h>

void main()
{
char input;
cout<<"1. Play game";

13
Learning “C”

cout<<"2. Load game";

cout<<"3. Play multiplayer";
cout<<"4. Exit";
input=getch(); //Remember I said you don't need many functions...
switch(input)
{
case 1:
playgame();
break;
case 2:
loadgame();
break;
case 3: //Note use of : not ;
playmultiplayer();
break;
case 4:
break;
default:
cout<<"Error, bad input, quitting";
}
}

If you are not understand this, then try putting in if statements for the case
statements. Also, the reason exit works with a break is that after you break out of the switch
statement then it would be the end of the program. The same thing would be for default. If
you don't like that, then make a loop around the whole thing. I know I did not prototype
the functions, but it was a very simple example. You could easily make a few small functions.

14
Learning “C”

LESSON 6
An Introduction to Pointers
Welcome to the sixth in my series of tutorials. This is one about a topic that you
may or may not have already heard about...pointers. What are they, what do they do, why do
we care? First, why do we care?
We care about pointers because they allow access to memory, the also make array-
access faster, they are also somewhat necessary to understand some functions. Most
importantly, you will see them a lot in other people's code. You may not need to use them
much, but it will be tremendously important to understand them.
Second, what do they do. Well, I might as well address this issue as well as what they
are at the same time. Pointers are what they sound like...pointers. They point to locations in
memory. Picture this: a big jar that holds one thing, the name of another jar. In the other
jar is the value of an integer. The jars are memory locations. The jar that holds the name of
the other jar is a pointer. It points to the other drawer.
How can you use this? Well, look at this little piece of code:

#include <iostream.h>
void main()
{
int x;
int *pointer;
pointer=&x;
cin>>x;
cout<<*pointer;
}

Guess what! The cout outputs the value in x. Why is that? Well, look at the code.
The integer is called x. Then a pointer to an integer is defined as pointer. The astrick(*)
symbol means that it is a pointer. Then I give the memory location of x to pointer by using
the ampersand(&) symbol. It gives the memory location of the variable it is in front of. For
example, if the jar that had an integer had a ampersand in it it would output its name, or
location.

Then the user inputs the value for x. Then the cout uses the * to put the value
stored in the memory location of pointer. Huh? Picture the jars again. If the jar with the
name of the other jar in it had a * in front of it it would give the value stored in the jar with
the same name as the one in the jar with the name. It's not too hard, the * gives the value in
the location. The unastricked gives the memory location.

I hope this has been at least an interesting introduction to pointers. I do not suggest
that you play around with them too much as you can do unpleasant things on your
computer, but you now should have a better understand of what they are.

15
Learning “C”

LESSON 7
Structures
Welcome to the seventh lesson. This is my first lesson that I will explain classes.
However, I will explain more about structures, because they can be useful, and they are a
good way to get a feel for how a class works. What are structures? They are a way to store
more than one data-type under the same name. Fore example:

#include <string.h> //For strcpy

struct database
{
int age;
char name[20];
float salary;
};

void main()
{
database employee;
employee.age=22;
strcpy(employee.name, "Joe");
employee.salary=12000.21;
}

Don't worry about the name[20]. That is just an array. It can hold more than one
character all called under the same name. They are used like strings. I will do my next
lesson on arrays, I promise, because they are very important. The struct database declares
that database has three variables in it, age, name, and salary.

Eventually, you can use database like a variable type like int. You can create an
employee with the database type like I did above. Then, to modify it you call everything
with the employee. in front of it. You can also return structures from functions by defining
their return type as a structure type. Example:

struct database fn();

You can make arrays of structures as well. I will show you how to do this in lesson
8. That will be up in a few days. I suppose I should explain unions a little bit. They are like
structures except that all the variables share the same memory. When a union is declared
the compiler allocates enough memory for the largest data-type in the union.

To access the union you use the . like in structures. Also, if you are accessing the
union of structure through a pointer use the -> operator. for example, database->employee
. The most useful thing about unions is that you can manipulate the bytes of the data-types.
You might want to see what you can do if you understand that sort of stuff. Personally, I
have never used a union.

16
Learning “C”

LESSON 8
Array basics
This is the eighth installment of my lessons, and it is on arrays. Arrays are essentially
a way to store many values under the same name. You can make an array out of any data-
type, including structures. For example, you could say

int examplearray[100]; //This declares an array

This would make an integer array with 100 slots, or places to store values. The only
difficult thing is that it starts off with the first index-number, that is, the number that you put
in the brackets to access a certain element, is zero, not one!

Think about arrays like this: [][][][][][] Each of the slots is a slot in the array, and you
can put information into each one of them. It is like a group of variables side by side almost.

What can you do with this simple knowledge? Lets say you want to store a string,
since C++ has no built-in datatype for strings, in DOS, you can make an array of characters.

For example:

char astring[100];

Will allow you to declare a char array of 100 elements, or slots. Then you could get
it from the user, and if the user types in a long string, it will all go in the array. The neat
thing is that it is very easy to work with strings in this way, and there is even a header file
called STRING.H. I will have a lesson in the future on the functions in string.h, but for
now, lets concentrate on arrays.

The most useful aspect of arrays is multidimensional arrays.

For example:

int twodimensionalarray[8][8];

Think about multidimensional arrays:

[][][][][]
[][][][][]
[][][][][]
[][][][][]
[][][][][]

This is a graphic of what a two-dimensional array looks like when I visualize it.
Declares an array that has two dimensions. Think of it as a chessboard. You can easily use
this to store information about some kind of game, or write something like tic-tac-toe. To

17
Learning “C”

access it, all you need are two variables, one that goes in the first slot, one that goes in the
slot. You can even make a three dimensional array, though you probably won't need to. In
fact, you could make a four-hundred dimensional array. It is just is very confusing to
visualize.

Now, arrays are basically treated like any other variable. You can modify one value in
it by putting:

arrayname[arrayindexnumber]=whatever;

You will find lots of useful things to do with arrays, from store information about
certain things under one name, to making games like tic-tac-toe. One little tip I have is that
you use for loops to access arrays. It is easy:

#include <iostream.h>

void main()
{
int x, y, anarray[8][8];//declares an array like a chessboard
for(x=0; x<8; x++)
{
for(y=0; y<8; y++)
{
anarray[x][y]=0;//sets all members to zero once loops is done
}
}
for(x=0; x<8;x++)
{
for(y=0; y<8; y++)
{
cout<<"anarray["<<x<<"]["<<y<<"]="<<anarray[x][y]<<" ";//you'll see
}
}
}

Here you see that the loops work well because they increment the variable for you,
and you only need to increment by one. It is simple, and you access the entire array, would
you want to use while loops?

18
Learning “C”

LESSON 9
Strings
This lesson is one on strings. Strings are really arrays, but there are some different
functions that are used for strings, like adding to strings, finding the length of strings, and
also of checking to see if strings match. Strings are basically sentences, or words. Like,
"This is a string".

Strings are basically character arrays. For example, to declare a string of 50 letters,
you would want to say:

char string[50];

This would declare a string with a length of 50 characters. Don't forget that arrays
begin at 0, not 1 for the index-number. Also, a string ends with a null character, literally a
'/0' character. But, just remember that there will be an extra character on the end on a
string. It is like a period at the end of a sentence, it is not counted as a letter, but it still takes
up a space.

What are strings useful for? Well, for one thing, you might want to get a person's
name. If you wanted to, you would need a string, because a name can't fit in one variable! It
is, however, a collection of characters, and so fits nicely into a character array.

Now, what if you want to input a string? Well, if you try to use cin>> then it won't
work! It terminates at the first space. However, you can use the function gets(char *s);
.
Gets is basically a function that reads in a string and stops reading at the first new-
line, for example, when a user hits enter. Gets is in stdio.h. All you do, is put the name of
the array and it will work out, because the pointer char *s is basically one way you tell a
function that you will be passing an array, although it is a pointer, it is still the string you
give. Essentially, char *s points to a string, and you can access this string just like an array.

I will touch upon this relationship as described above in another lesson that will be a
more advanced lesson on pointers and arrays.

Anyway, to get a string from a user you want to use gets. An example program of
this would be:

#include <stdio.h> //For gets

#include <iostream.h> //For all other input/output functions
void main()
{
char astring[50]; //This declares a character array that can be used as a string
cout<<"Please enter a string"; //You should know this one!
gets(astring); //The user will input a string(with spaces)
cout<<"You input: "<<endl; //You know this one too!

19
Learning “C”

cout<<astring; //This is how you output character arrays, but not

others!
}
Ok, thats pretty simple. But, what if you want to use some of the nifty functions from
string.h?

Well, these include the following functions:

int strcmp(const char *s1, const char *s2);

strcmp will accept two strings. It will return an integer. This integer will either be:
Negative if s1 is less than s2.
Zero if s1 and s2 are equal.
Positive if s1 is greater than s2.

Strcmp is case sensitive.

int strcmpi(const char *s1, const char *s2);

strcmp will accept two strings. It will return an integer. This integer will either be:
Negative if s1 is less than s2.
Zero if the s1 and s2 are equal.
Positive if s1 is greater than s2.

Strcmpi is not case sensitive, if the words are capitalized it doesn't matter.

char *strcat(char *desc, char *src);

strcat is short for string cacatenate, which means to add to the end, or append. It does just
this,
the first string is what the second string is stuck on the end of. It basically returns the
cacatenated string. The first string will also have the entire string added to it.

char *strupr(char *s);

strupr converts a string to uppercase. It also returns a string, which will all be in uppercase.
The input string, if it is an array, will also all be uppercase.

char *strlwr(char *s);

strlwr converts a string to lowercase. It also returns a string, which will all be in uppercase.
The input string, if it is an array, will also all be uppercase.

size_t strlen(const char *s);

strlen will return the length of a string, minus the termating character(/0). The size_t is
nothing to worry about. Just treat it as an integer.

20
Learning “C”

Some of the stuff in the strings may be confusing. The const char *s stuff, for
example. But, just remember that basically all of that will be a string! It doesn't matter what
the code is right now, just what the functions do.

Now, a small program using many of the string functions!

#include <iostream.h> //For cout

#include <string.h> //For many of the string functions
#include <stdio.h> //For gets

void main()
{

char name[50]; //Declare variables

char lastname[50]; //This could have been declared on the last line...
cout<<"Please enter your name: "; //Tell the user what to do
gets(name); //Use gets to input strings with spaces or just to get strings after the
user presses enter

if(!strcmpi("Alexander", name)) //The ! means not, strcmpi returns 0 for equal strings
{ //strcmpi is not case sensitive
cout<<"That's my name too."<<endl; //Tell the user if its my name
}
else //else is used to keep it from always outputting cout<<"That's not
my name."
{
cout<<"That's not my name."<<endl;
}

cout<<"What is your name in uppercase..."<<endl;

strupr(name); //strupr converts the string to uppercase
cout<<name<<endl;
cout<<"And, your name in lowercase..."<<endl;
strlwr(name); //strlwr converts the string to lowercase
cout<<name<<endl;
cout<<"Your name is "<<strlen(name)<<" letters long"<<endl; //strlen returns the
length of the string
cout<<"Enter your last name:";
gets(lastname); //lastname is also a string
strcat(name, " "); //We want to space the two names apart
strcat(name, lastname); //Now we put them together,we a space in the middle
cout<<"Your full name is "<<name; //Outputting it all...
}

21
Learning “C”

LESSON 10
File I/O (part 1)
This is a slightly more advanced topic than what I have covered so far, but I think
that it is useful, and I think it will be useful to many people. File i/o is basically reading, and
writing files. This lesson will only cover text files, that is, files that are readable through a
text editor, as opposed to binary files(exes for example). It will not cover a great deal, for
example, this lesson will not deal with searching files or reading specific data from files. It
will merely be concerned with opening, writing, and reading text files. Don't worry though,
lesson 11 will cover much more on this topic.

Well, how does it all start anyway? Files have their own specific functions to use, as
well as their own data-type, called a FILE(There is more to this, but right not it is not
important, and it will be explained later, when it is useful). The way to use the FILE type is
the same way as using an integer, or a float, or a char:

FILE *newfile; //Creates a FILE called newfile(don't forget that it is a pointer)

Now, we can't use this unless there is a way to give the FILE(*newfile) a file to point
to. The way this works is that it is what is called a stream. That means that it is where the
output will go to. To direct *newfile to a file the command to use is FILE *fopen(const
char *filename, const char *mode), found in stdio.h. It simply returns a pointer to a FILE,
but it is easy enough to use. For example:

FILE *newfile: //Creates a FILE called newfile

newfile=fopen("c:\AUTOEXEC.BAT", "r");//open up for reading your autoexec.bat file,
and assign
//it to newfile
Basically, fopen accepts two strings. One of them is the file name, including the
path,and the other is what the file will be used for(the mode). In this case, the r designates
the file will only be opened for reading. Therefore, the file cannot be modified while it is
open. That is probably a good idea, because editing your autoexec.bat file with giberish is
not a good idea!

For a reference here is a chart listing the different ways you open a file:

r Open for reading only.

w Creates a file for writing. If a file by that name already exists, it will be overwritten.
a Append; open for writing at the end of the file, or create the file if it does not exist.
r+ Open an existing file for reading and writing.
w+ Create a new file for reading and writing. If a file by that name already exists, it will
be overwritten.
a+ Open for append; open (or create if the file does not exist) for update at the end of
the file.

22
Learning “C”

Keep in mind that each of these has a different use, and that you should choose the
one most appropriate for you task. For now however, lets concentrate on reading a file.

Now, let's say you want to print the contents of autoexec.bat to your screen.
Assuming you want to make a program to do this you would need a function for reading
from a file. There are numerous useful ones, but for now we will use int fgetc(FILE
*stream)(Note that it returns an int, but the range will still be printable(so it is the same as a
char), defined in iostream.h. Basically, fgetc will get the next character from a file you give
it(that is, the stream you give it). An example would be the following code to display the
first few characters of your autoexec.bat file:

#include <iostream.h> //For cout

#include <stdio.h> //For all file i/o functions

void main()
{
int count=0; //Just a variable to keep from reading the file forever.
FILE *afile; //We need a FILE to point to the stream to allow access to the fil
afile=fopen("c:/AUTOEXEC.BAT", "r"); //Open up the autoexec.bat file for reading
//No, I do not know why it must be a forward slash.
while(count<10)
{
cout<<(char)fgetc(afile); //Notice that fgetc returns an int, which can be printed.

//Please note the use of (char) to 'typecast' the returned integer. That means that it
makes
//it into a printable character from the number. There is more on this in lesson 11,
which
//I suggest you read.(Note that chars basically convert their ASCII numbers into the
//appropriate printable characters. 65='A' for example.

count++; //I don't think it should read forever, right?

}
fclose(afile); //A surprise(don't worry, just use it to close a file when done).
//Just put in the pointer to the stream(the
FILE thingy)
}

This program is fairly simple, and it does not take advantage of many of C's more
useful file operations. Note though, that it is going to print out only a few characters. What
if you wanted to print the entire file out, though? Well, that is where a thing called the
EOF(end-of-file) comes into play. It is essentially a null that will signal the end of the file
has been reached.

So, how would you make a program to use this? Well, fgetc retrieves a character
from the file, and it will return the EOF when it reaches the end of the file. Now, it is
possible to use a loop that will check to see if the last character is equal to the EOF. For

23
Learning “C”

example, CHARACTERREAD!=EOF. This would return true if the CHARACTERREAD

is not the EOF.
Here's how I would do it:

#include <iostream.h> //For cout

#include <stdio.h> //For all file i/o functions

void main()
{
FILE *afile; //We need to define a FILE type to open a file
afile=fopen("c:/AUTOEXEC.BAT", "r"); //Opens autoexec.bat, only to read, not write it.
afile
//is now the stream
pointing to the file autoexec.bat,
//and is used to do
operations with autoexec.bat
char c; //Without a character to store the information the program won't work
while(c!=EOF) //Checking to see if the character just read is the end of the file
{
c=fgetc(afile); //This reads in the character
//Note that it is not necessary to typecast the fgetc return, as it is automatically turned
//into a printable character when char c is a character.
cout<<c; //The prints out the character(as you SHOULD know!)
}
fclose(afile); //Just to be safe, close the file!
}

Ok, so you finally got it to print out! Well, what is the next thing to do? Why not
have a program to make a backup of autoexec.bat? There is a new function that you will
need to add to your repertoire before this can be done. The new function is fputc, defined
in stdio.h. int futc(int c, FILE *filethinghere);. Basically, it will return the character given to
it, or it will return an EOF. It accepts a character as the first argument, and a pointer to a
stream(the FILE thing) as the second argument. Here is an example of how to use it:

fputc('A', newfile); //Writes the character 'A' to the file pointed to by newfile

However, don't forget that this does not always work. The file the stream points to
has to have been opened for writing, not just reading. Usually you will want to append to a
file, but in the case of our next example we want to create a new file, and overwrite an old
one.

Now that we have a function to print to a file, why not finish up with one program
to backup autoexec.bat. Basically, we will use the same loop as in the first function, that is,
checking to see if the end of the file is reached, otherwise it will continue to print out
characters. This time however, it will not print the characters to the screen. Instead, it will
print the characters to another file(In the example, backup.aut).

-----------------------------------------------------------------------------------------------

24
Learning “C”

WARNING: If you currently have a file called backup.aut you will have it overwritten! DO
NOT run the example program if you have the file backup.aut in the directory with your
compiler! Otherwise, you will hae it overwritten.
-----------------------------------------------------------------------------------------------

#include <stdio.h> //Needed for file i/o functions(including fopen!)

void main()
{
FILE *autoexec, *backup; //There are two files this time, the AUTOEXEC.BAT and the
backup
// file
autoexec=fopen("c:\AUTOEXEC.BAT", "r");//Open autoexec.bat to read the file
backup=fopen("backup.aut", "w"); //Create(or overwrite)backup.aut for writing
char c; //We need a buffer for reading in the charactesr
while(c!=EOF) //Just checking to see if it's the end of the file
{
c=fgetc(autoexec); //Reading in a character from autoexec.bat
fputc(c, backup); //Writing a character to the backup file!
}
fclose(autoexec);
fclose(backup); //Closing the files to finish it all up!
}

Wow! It's a program that could be useful. Feel free to use it anytime you like. Just
remember how it works. Don't think this is the end of the file i/o information. There is
more, but for now this should be enough to whet your appetite. Oh, and you case use fputc
to write user input to a file also! I think you can figure it out!

25
Learning “C”

LESSON 11
Typecasting
Admittedly, typecasting is not a huge part of C or C++ programming. However,
there are times when it is actually the best, or perhaps only, way to accomplish something.
Typecasting is basically turning a variable of one type, say an int, into another type, a char,
for one a single application.

Typecasts look like a data-type, like int, in between two parentheses. (char)aninteger
will interpreted as a character for purposes of the function.

For example:
#include <iostream.h> //For cout

void main()
{
cout<<(char)65; //The (char) is a type cast, telling the computer to interpret the 64 as a
//character, not as a number. It is going to give the ASCII output of the
//equivalent of the number 64(It should be the letter A).
}

One use of typecasting is when you want to use the ASCII characters. For example,
what if you want to create your own chart of all 255 ASCII characters. To do this, you will
need to use a typecast to allow you to print out the integer as a character.

#include <iostream.h>
#include <conio.h>

void main()
{
for(int x=1; x<256; x++) //The ASCII character set is from 1 to 255
{
cout<<x<<". "<<(char)x<<" "; //Note the use of the int version of x to output a
number
//and the use of (char) to typecast the x into a character
//which outputs the ASCII character that corresponds to
the
//current number
}
getch();
}
You can make a version of this program that will allow the user to enter a number,
and the program could give the user the character corresponding to the number.

Typecasting is more useful than this, but this was just an introduction. Admittedly,
not the most advanced lesson, but one that can be very useful none-the-less.

26
Learning “C”

My homepage is
http://www.cprogramming.com

My email is
lallain@concentric.net

Please email me with comments and or suggestions. If you

want to use this on your own site please email me and add a
link to
http://www.cprogramming.com

Thanks

Editing By:-
Manoj Kumar
Himachal Pradesh, India

27