C-LANGUAGE
NOTES
Some words about Computer Programming languages
Naturally
a language is the source of communication between two persons, and
also between person to machine like computer. The languages we can use to
communicatewith the computer are known as Computer programming
languages.Generally there are two major types of languages are available are as
follows:1.
Low level languages
2.The set of commands available in low level is
complex and not easy tounderstandable. In this category " Assembly
" and " machine codes " areavailable. Assembly programs are
faster than other high-level language programs.3.
High level languages
The
set of commands available in high level language is very simple and easy
to
understandable.High level languages are further divided into two major
categories.
1.Procedure Oriented language
2.In this category we are able to create our project or
programs using proceduralapproach
means in this type we can able to divide our big project/program intosmall
subroutines or procedures. After making procedures we can able to call
a‘procedure’ one or more places.The lists of procedural languages are as
follows:C languageC++ (Object Oriented)Java (Objected Oriented)Smalltalk
(Objected Oriented)Pascal language3.
Non-Procedural
Languages:
This
category also known as ‘Problem Orientedlanguages’. In this type of languages
we can able to make program only atspecific range like database. The followings
are the examples of Non procedural languages.
1.1.SQL (Structured Query Language)2.SNOBOL (String processor)
C LanguageHistory
•
Developed
at Bell Laboratories. first standard version release in 1972.
•
Developed
by Dennis Richee.
•
Before
c a Programming language is very popular in those days the name of thelanguage
is B-Language so the developers decided the name of ‘C’ language because C
is next to B.
The Integrated Development Environment (IDE):
Turbo
c features as integrated Development environment, or IDE,. It is also referred
to asthe programmer’s platform.) in IDE you can able to write/save/open your
programs or code, compile using short cut keys, and also perform code
debugging very easily.
IDE
Common Short cut Keys Description
F2
press to Save current work F3 press to open an existing fileALT-F3 press
to close currentALT-F9 press to compile onlyALT-F5 press to view the desired
output of the program.CTRL-F9 press to compile+runALT-X or ALT-F-X press to
exit from TC IDE
C Programs Skeleton (General)
<Preprocessor
Directives (some time necessary)><Macros Definition
(optional)><function declaration>
<
Global Variable (on your demand)>main () (Necessary){ statements }<
function definition>{ }
Remember Some common rules for writing C program
•
Use
all commands or statements in lower or small case.
•
After
completion of a statement excluding main() or loops must insert
;
(semicolon)
as a statement terminator.
•
Don’t
use/declare identifier or variable name same as statement name suppose
int include
;
this is a wrong statement because include has a special meaning in thelanguage.
Header Files or Preprocessor Directives
contains
references or links of library functions. That is built-in in the C
language.
Suppose
if
you want to use a function clrscr() ; in the main function so must bedeclared
on top # include <conio.h> other wise you could have an prototype error.
Some header files are as follows
Stdio.h
Conio.hDos.hString.hStdlib.h
And
many more header files are available in C…
void main(void)
Every C programs consists of one or
more functions. No matter how manyfunctions there are in a C program , main is
the one to which control is passedfrom the operating system when the program is
run ; it is the first function
executed.
The word "void" preceding "main" specifies that the
function main()will not return a value. The second "void," in
parenthesis , specifies that thefunction takes no arguments.
printf()
printf()
is built-in function we can display with printf() any message, variablevalue on
screen/file/printer.
In
printf() we can use many escape sequences and format specifies.
Escape
sequences
are
special notations through which we can display our dataVariety of ways:Some
escape sequences and their functions are as follows:
EscapeSequenceDescriptionExample\n
Perform line feed & Carriage return
operationprintf("A\nB");
\t
Prints a tab sequence on screenprintf ("A\tb");
\’
Prints a single quote character on screenprintf
("\’a\’");
\"
Prints a double quote character on Screenprintf
("\"a\"");
\r
Perform
carriage return operation printf ("a\rb")
\b
Remove one character from leftprintf ("a\bHi!"
);
Example Program #1
#include
<stdio.h>
#include
<conio.h>
void
main(void){ printf( " Example Program (Escape Sequence) \n");
printf(
" -----------------------------------------------\n"); printf(
"Escape sequnce \t Meaning\n"); printf( "
-------------------------------------------------\n"); printf("
\\\\ \t \\" \n"); printf("
\t
perform only line feed\n");getch();}
This program produces following output
Example
Program (Escape Sequence)--------------------------------------------
Escape Sequence Meaning
------------------------------------------
\\
\
\’
‘
\"
\"\n line feed & carriage return\t Tab Characters or eight spaces\b
Erase one char from right to left
\r
perform only line feed
Example Program #2
#include
<stdio.h>
#include
<conio.h>
void
main(void){clrscr(); printf( " \" Pakistan ZindaBad\"
\n");getch();}
This program produces following output
"Pakistan
ZindaBad"
Description :
in
the above we use a escape sequence \" this will produce " onscreen
after that a message Pakistan ZindaBad is appear after the message
another " ( double quotation) appear on screen because of \"
Variable
:
variables
are named peace of memory in which we can store our dataand manipulate our
data. Variables are used so that same space in memory canhold different values
at different times.In C language following are the list of data type available
through which we candefine our variables:
•
int
(Example :int a,b,c)
•
float(Example:float
pi;)
•
char(Example
:char opt;)
•
long(long
bigval;)
•
double(double
bigval;)
Data Types Range Memory occupy
int
-32768 to +32767 without fractional) 2 bytesunsigned int 0 to 65,535 2 bytes
char
-128 to 127 1 bytechar 0 to 256 1 byteenum -32768 to 32,767 2 bytesfloat 3.4 *
(10**-38) 4 bytesdouble 1.7 * (10**-308) 8 byteslong double 3.4 * (10**-4932)
10 bytes
Variables
In
C, a variable must be declared before it can be used. Variables can be declared
at thestart of any block of code, but most are found at the start of each
function. Most localvariables are created when the function is called, and are
destroyed on return from thatfunction.A declaration begins with the type,
followed by the name of one or more variables. For example,
int high, low, results[20];
Declarations
can be spread out, allowing space for an explanatory comment. Variablescan also
be initialised when they are declared, this is done by adding an equals sign
andthe required value after the declaration.
int high = 250; /* Maximum Temperature */int low = -40;
/* Minimum Temperature */int results[20]; /* Series of temperature readings */
C
provides a wide range of types. The most common are
Variable
Names
Every
variable has a name and a value. The name identifies the variable, the value
storesdata. There is a limitation on what these names can be. Every variable
name in C muststart with a letter, the rest of the name can consist of letters,
numbers and underscorecharacters. C recognises upper and lower case characters
as being different. Finally, youcannot use any of C's keywords like main,
while, switch etc as variable names.Examples of legal variable names include
x result outfile bestyetx1 x2 out_file best_yetpower
impetus gamma hi_score
It
is conventional to avoid the use of capital letters in variable names. These
are used for names of constants. Some old implementations of C only use
the first 8 characters of avariable name. Most modern ones don't apply this
limit though. The rules governing
variable names also apply to the names of functions. We shall meetfunctions
later on in the course.
Global
Variables
Local
variables are declared within the body of a function, and can only be used
withinthat function. This is usually no problem, since when another function is
called, allrequired data is passed to it as arguments. Alternatively, a
variable can be declaredglobally so it is available to all functions. Modern
programming practice recommendsagainst the excessive use of global variables.
They can lead to poor program structure,and tend to clog up the available name
space.A global variable declaration looks normal, but is located outside any of
the program'sfunctions. This is usually done at the beginning of the program
file, but after preprocessor directives. The variable is not declared
again in the body of the functions which access it.
Static
Variables
Another
class of local variable is the static type. A static can only be accessed from
thefunction in which it was declared, like a local variable. The static
variable is notdestroyed on exit from the function, instead its value is
preserved, and becomes availableagain when the function is next called. Static
variables are declared as local variables, butthe declaration is preceeded by
the word static.
static int counter;
Static
variables can be initialised as normal, the initialisation is performed once
only,when the program starts up.
Constants
A
C constant is usually just the written version of a number. For example 1, 0,
5.73,12.5e9. We can specify our constants in octal or hexadecimal, or force
them to be treatedas long integers.
•
Octal
constants are written with a leading zero - 015.
•
Hexadecimal
constants are written with a leading 0x - 0x1ae.
•
Long
constants are written with a trailing L - 890L.Character constants are usually
just the character enclosed in single quotes; 'a', 'b', 'c'.Some characters
can't be represented in this way, so we use a 2 character sequence.In addition,
a required bit pattern can be specified using its octal equivalent.'\044'
produces bit pattern 00100100.Character constants are rarely used, since string
constants are more convenient. A stringconstant is surrounded by double quotes
eg "Brian and Dennis". The string is actuallystored as an array of
characters. The null character '\0' is automatically placed at the endof such a
string to act as a string terminator.A character is a different type to a
single character string. This is important.We will meet strings and characters
again when we deal with the input / output functionsin more detail.
Expressions
and Operators
One
reason for the power of C is its wide range of useful operators. An operator is
afunction which is applied to values to give a result. You should be familiar
with operatorssuch as
+
,
-, /.Arithmetic operators are the most common. Other operators are used for
comparison of values, combination of logical states, and manipulation of
individual binary digits. The binary operators are rather low level for so
are not covered here.Operators and values are combined to form expressions. The
values produced by theseexpressions can be stored in variables, or used as a
part of even larger expressions.
Assignment
Statement
The
easiest example of an expression is in the assignment statement. An expression
isevaluated, and the result is saved in a variable. A simple example might look
like
y = (m * x) + c
This
assignment will save the value of the expression invariable y. Arithmetic
operators
Here
are the most common arithmetic operators*, / and % will be performed before
+
or
- in any expression. Brackets can be used toforce a different order of
evaluation to this. Where division is performed between twointegers, the result
will be an integer, with remainder discarded. Modulo reduction is onlymeaningful
between integers. If a program is ever required to divide a number by zero,this
will cause an error, usually causing the program to crash.Here are some
arithmetic expressions used within assignment statements.
velocity = distance / time;force = mass *
acceleration;count = count + 1;
C
has some operators which allow abbreviation of certain types of arithmetic
assignmentstatements.These operations are usually very efficient. They can be
combined with another expression.
Versions
where the operator occurs before the variable name change the value of
thevariable before evaluating the expression, soThese can cause confusion if
you try to do too many things on one command line. Youare recommended to
restrict your use of
++
and
-
to
ensure that your programs stayreadable.Another shorthand notation is listed
below
Comparison
C
has no special type to represent logical or boolean values. It improvises by
using any of the integral types char, int, short, long, unsigned, with a
value of 0 representing false andany other value representing true. It is rare
for logical values to be stored in variables.They are usually generated as
required by comparing two numeric values. This is wherethe comparison operators
are used, they compare two numeric values and produce alogical
result. Note that == is used in comparisons and = is used in assignments.
Comparison operatorsare used in expressions like the ones below.
x == yi
> 10a + b != c
In
the last example, all arithmetic is done before any comparison is made.
These
comparisons are most frequently used to control an if statement or a for or a
whileloop. These will be introduced in a later chapter.
Logical
Connectors
These
are the usual And, Or and Not operators.They are frequently used to combine
relational operators, for example
x < 20 && x >= 10
In
C these logical connectives employ a technique known as lazy evaluation.
Theyevaluate their left hand operand, and then only evaluate the right hand one
if this isrequired. Clearly false && anything is always false, true ||
anything is always true. Insuch cases the second test is not
evaluated. Not operates on a single logical value, its effect is to
reverse its state. Here is an exampleof its use.
if ( ! acceptable )printf("Not Acceptable
!!\n");
Control
Statements
A
program consists of a number of statements which are usually executed in
sequence.Programs can be much more powerful if we can control the order in
which statements arerun.Statements fall into three general types;
•
Assignment,
where values, usually the results of calculations, are stored invariables.
•
Input
/ Output, data is read in or printed out.
•
Control,
the program makes a decision about what to do next.This section will discuss
the use of control statements in C. We will show how they can be used to
write powerful programs by;
•
Repeating
important sections of the program.
•
Selecting
between optional sections of a program.
The
if else Statement
This
is used to decide whether to do something at a special point, or to decide
betweentwo courses of action.The following test decides whether a student has
passed an exam with a pass mark of 45
if (result >=
45)printf("Pass\n");elseprintf("Fail\n");
It
is possible to use the if part without the else.
if (temperature < 0)print("Frozen\n");
Each
version consists of a test, (this is the bracketed statement following the if).
If the testis true then the next statement is obeyed. If is is false then the
statement following theelse is obeyed if present. After this, the rest of the
program continues as normal.If we wish to have more than one statement
following the if or the else, they should begrouped together between curly
brackets. Such a grouping is called a compoundstatement or a block.
if (result >= 45){
printf("Passed\n");printf("Congratulations\n")}else{
printf("Failed\n");printf("Good luck in the resits\n");}
Sometimes
we wish to make a multi-way decision based on several conditions. The
mostgeneral way of doing this is by using the else if variant on the if
statement. This works bycascading several comparisons. As soon as one of these
gives a true result, the followingstatement or block is executed, and no
further comparisons are performed. In thefollowing example we are awarding
grades depending on the exam result.
if (result >= 75)printf("Passed: Grade
A\n");else if (result >= 60)printf("Passed: Grade B\n");else
if (result >= 45)printf("Passed: Grade
C\n");elseprintf("Failed\n");
In
this example, all comparisons test a single variable called result. In other
cases, eachtest may involve a different variable or some combination of tests.
The same pattern can be used with more or fewer else if's, and the final
lone else may be left out. It is up to the programmer to devise the
correct structure for each programming problem.
The
switch Statement
This
is another form of the multi way decision. It is well structured, but can only
be usedin certain cases where;
•
Only
one variable is tested, all branches must depend on the value of that
variable.The variable must be an integral type. (int, long, short or char).
•
Each
possible value of the variable can control a single branch. A final, catch
all,default branch may optionally be used to trap all unspecified
cases.Hopefully an example will clarify things. This is a function which
converts an integer into a vague description. It is useful where we are
only concerned in measuring a quantitywhen it is quite small.
estimate(number)int number;/* Estimate a number as none,
one, two, several, many */{ switch(number) {case 0
:printf("None\n");break;case 1 :printf("One\n");break;case
2 :printf("Two\n");break;case 3 :case 4 :case 5
:printf("Several\n");break;default :printf("Many\n");break;}}
Each
interesting case is listed with a corresponding action. The break statement
preventsany further statements from being executed by leaving the switch. Since
case 3 and case 4have no following break, they continue on allowing the same
action for several values of number.Both if and switch constructs allow
the programmer to make a selection from a number of possible actions.The
other main type of control statement is the loop. Loops allow a statement, or
block of statements, to be repeated. Computers are very good at repeating
simple tasks manytimes, the loop is C's way of achieving this.
Loops
C
gives you a choice of three types of loop, while, do while and for.
•
The
while loop keeps repeating an action until an associated test returns
false.This is useful where the programmer does not know in advance how many
timesthe loop will be traversed.
•
The
do while loops is similar, but the test occurs after the loop body is
executed.This ensures that the loop body is run at least once.
•
The
for loop is frequently used, usually where the loop will be traversed a
fixednumber of times. It is very flexible, and novice programmers should take
care notto abuse the power it offers.
The
while Loop
The
while loop repeats a statement until the test at the top proves false.As an
example, here is a function to return the length of a string. Remember that
thestring is represented as an array of characters terminated by a null
character '\0'.
int string_length(char string[]){ int i = 0;while
(string[i] != '\0')i++;return(i);}
The
string is passed to the function as an argument. The size of the array is not
specified,the function will work for a string of any size.The while loop is
used to look at the characters in the string one at a time until the
nullcharacter is found. Then the loop is exited and the index of the null is
returned. While thecharacter isn't null, the index is incremented and the test
is repeated.
The
do while Loop
This
is very similar to the while loop except that the test occurs at the end of the
loop body. This guarantees that the loop is executed at least once before
continuing. Such asetup is frequently used where data is to be read. The test
then verifies the data, and loops back to read again if it was
unacceptable.
do{ printf("Enter 1 for yes, 0 for no
:");scanf("%d", &input_value);} while (input_value != 1
&& input_value != 0)
The
for Loop
The
for loop works well where the number of iterations of the loop is known before
theloop is entered. The head of the loop consists of three parts separated by
semicolons.
•
The
first is run before the loop is entered. This is usually the initialisation of
theloop variable.
•
The
second is a test, the loop is exited when this returns false.
•
The
third is a statement to be run every time the loop body is completed. This isusually
an increment of the loop counter.The example is a function which calculates the
average of the numbers stored in an array.The function takes the array and the
number of elements as arguments.
float average(float array[], int count){ float total = 0.0;int
i;for(i = 0; i < count; i++)total += array[i];return(total / count);}
The
for loop ensures that the correct number of array elements are added up
beforecalculating the average.The three statements at the head of a for loop
usually do just one thing each, however anyof them can be left blank. A blank
first or last statement will mean no initialisation or running increment.
A blank comparison statement will always be treated as true. Thiswill cause the
loop to run indefinitely unless interrupted by some other means. This
might be a return or a break statement.It is also possible to squeeze
several statements into the first or third position, separatingthem with
commas. This allows a loop with more than one controlling variable. Theexample
below illustrates the definition of such a loop, with variables hi and lo
starting at100 and 0 respectively and converging.
for (hi = 100, lo = 0; hi >= lo; hi--, lo++)
The
for loop is extremely flexible and allows many types of program behaviour to
bespecified simply and quickly.
The
break Statement
We
have already met break in the discussion of the switch statement. It is used to
exitfrom a loop or a switch, control passing to the first statement beyond the
loop or a switch.
With
loops, break can be used to force an early exit from the loop, or to implement
a loopwith a test to exit in the middle of the loop body. A break within a loop
should always be protected within an if statement which provides the test
to control the exit condition.
The
continue Statement
This
is similar to break but is encountered less frequently. It only works within
loopswhere its effect is to force an immediate jump to the loop control
statement.
•
In
a while loop, jump to the test statement.
•
In
a do while loop, jump to the test statement.
•
In
a for loop, jump to the test, and perform the iteration.Like a break, continue
should be protected by an if statement. You are unlikely to use itvery often.
The
goto Statement
C
has a goto statement which permits unstructured jumps to be made. Its use is
notrecommended, so we'll not teach it here. Consult your textbook for details
of its use.
Pointers
in C
Pointers
are not exclusive to functions, but this seems a good place to introduce
the pointer type.Imagine that we have an int called i. Its address could
be represented by the symbol &i. If the pointer is to be stored as a
variable, it should be stored like this.
int *pi = &i;
int
* is the notation for a pointer to an int. & is the operator which returns
the address of its argument. When it is used, as in &i we say it is
referencing i.The opposite operator, which gives the value at the end of the
pointer is *. An example of use, known as de-referencing pi, would be
i = *pi;
Take
care not to confuse the many uses of the * sign; Multiplication, pointer
declarationand pointer de-referencing.
This
is a very confusing subject, so let us illustrate it with an example. The
followingfunction fiddle takes two arguments, x is an int while y is a pointer
to int. It changes bothvalues.
fiddle(int x, int *y){ printf(" Starting fiddle: x =
%d, y = %d\n", x, *y);x ++;(*y)++;printf("Finishing fiddle: x = %d, y
= %d\n", x, *y);}
since
y is a pointer, we must de-reference it before incrementing its value.A very
simple program to call this function might be as follows.
main(){ int i = 0;int j = 0;printf(" Starting main :
i = %d, j = %d\n", i, j);printf("Calling fiddle
now\n");.fiddle(i, &j);printf("Returned from
fiddle\n");printf("Finishing main : i = %d, j = %d\n", i, j);}
Note
here how a pointer to int is created using the & operator within the call
fiddle(i,&j);.The result of running the program will look like this.
Starting main : i = 0 ,j = 0Calling fiddle nowStarting
fiddle: x = 0, y = 0Finishing fiddle: x = 1, y = 1Returned from fiddleFinishing
main : i = 0, j = 1
After
the return from fiddle the value of i is unchanged while j, which was passed as
a pointer, has changed.To summarise, if you wish to use arguments to
modify the value of variables from afunction, these arguments must be passed as
pointers, and de-referenced within thefunction.Where the value of an argument
isn't modified, the value can be passed without anyworries about pointers.
The
Standard Input Output File
UNIX
supplies a standard package for performing input and output to files or
theterminal. This contains most of the functions which will be introduced in
this section,along with definitions of the datatypes required to use them. To
use these facilities, your program must include these definitions by
adding the line This is done by adding the line
#include <stdio.h>
near
the start of the program file.If you do not do this, the compiler may complain
about undefined functions or datatypes.
Formatted
Input / Output
We
have met these functions earlier in the course. They are closest to the facilitiesoffered
by Pascal or Fortran, and usually the easiest to use for input and output.
Theversions offered under C are a little more detailed, offering precise
control of layout.
•
•
printf
This
offers more structured output than putchar. Its arguments are, in order; a
controlstring, which controls what gets printed, followed by a list of values
to be substituted for entries in the control string.There are several more
types available. For full details type
man printf
on
your UNIX system.It is also possible to insert numbers into the control string
to control field widths for values to be displayed. For example %6d would
print a decimal value in a field 6 spaceswide, %8.2f would print a real value in
a field 8 spaces wide with room to show 2decimal places. Display is left
justified by default, but can be right justified by putting a -
before
the format information, for example %-6d, a decimal integer right justified in
a 6space field.
scanf
scanf
allows formatted reading of data from the keyboard. Like printf it has a
controlstring, followed by the list of items to be read. However scanf wants to
know the addressof the items to be read, since it is a function which will
change that value. Therefore thenames of variables are preceeded by the &
sign. Character strings are an exception tothis. Since a string is already a
character pointer, we give the names of string variablesunmodified by a leading
&.Control string entries which match values to be read are preceeded by the
percentage signin a similar way to their printf equivalents.Type man scanf for
details of all options on your system.
Whole
Lines of Input and Output
Where
we are not too interested in the format of our data, or perhaps we cannot
predict itsformat in advance, we can read and write whole lines as character
strings. This approachallows us to read in a line of input, and then use
various string handling functions toanalyse it at our leisure.
•
•
gets
gets
reads a whole line of input into a string until a newline or EOF is
encountered. It iscritical to ensure that the string is large enough to hold
any expected input lines.When all input is finished, NULL as defined in stdio.h
is returned.
puts
puts
writes a string to the output, and follows it with a newline character.Example:
Program which uses gets and puts to double space typed input.
#include <stdio.h>main(){ char line[256]; /* Define
string sufficiently large to
store a line of input */while(gets(line) != NULL) /* Read
line */{ puts(line); /* Print line */printf("\n"); /* Print blank
line */}}
Note
that putchar, printf and puts can be freely used together. So can getchar,
scanf andgets.
Arrays
In
C, as in Fortran or PL/I, it is possible to make arrays whose elements are
basic types.Thus we can make an array of 10 integers with the declaration
int x[10];
The
square brackets mean subscripting; parentheses are used only for
functionreferences. Array indexes begin at zero, so the elements of
x
are
x[0], x[1], x[2], ..., x[9]
If
an array has
n
elements,
the largest subscript is
n-1
.Multiple-dimension
arrays are provided, though not much used above two dimensions.The declaration
and use look like
int name[10] [20];n = name[i+j] [1] + name[k] [2];
Subscripts
can be arbitrary integer expressions. Multi-dimension arrays are stored byrow
(opposite to Fortran), so the rightmost subscript varies fastest; name has 10
rows and20 columns.Here is a program which reads a line, stores it in a buffer,
and prints its length (excludingthe newline at the end).
main( ) {int n, c;char line[100];n = 0;while( (c=getchar(
)) != '\n' ) {if( n < 100 )line[n] = c;n++;}printf("length
= %d\n", n);}
As
a more complicated problem, suppose we want to print the count for each line in
theinput, still storing the first 100 characters of each line. Try it as an
exercise beforelooking at the solution:
main( ) {
int n, c; char line[100];n = 0;while( (c=getchar( )) !=
'\0' )if( c == '\n' ) {printf("%d0, n);n = 0;}else
{if( n < 100 ) line[n] = c;n++;}}
Strings
Text
is usually kept as an array of characters, as we did with
line[ ]
in
the exampleabove. By convention in C, the last character in a character array
should be a `\0' because most programs that manipulate character arrays
expect it. For example,
printf
uses
the `\0' to detect the end of a character array when printing it out with a
`%s'.We can copy a character array
s
into
another
t
like
this:
i = 0;while( (t[i]=s[i]) != '\0' )i++;
Most
of the time we have to put in our own `\0' at the end of a string; if we want
to printthe line with
printf
,
it's necessary. This code prints the character count before the line:
main( ) {int n;char line[100];n = 0;while(
(line[n++]=getchar( )) != '\n' );line[n] = '\0';printf("%d:\t%s", n,
line);}
Here
we increment
n
in
the subscript itself, but only after the previous value has beenused. The
character is read, placed in
line[n]
,
and only then
n
is
incremented.There is one place and one place only where C puts in the `\0' at
the end of a character array for you, and that is in the construction
"stuff between double quotes"
The
compiler puts a `\0' at the end automatically. Text enclosed in double quotes
iscalled a
string
;
its properties are precisely those of an (initialized) array of characters.
Functions
Suppose
we want, as part of a larger program, to count the occurrences of the
asciicharacters in some input text. Let us also map illegal characters (those
with value>127or <0) into one pile. Since this is presumably an isolated
part of the program, good practice dictates making it a separate function.
Here is one way:
main( ) {int hist[129]; /* 128 legal chars + 1
illegalgroup*/...count(hist, 128); /* count the letters into hist
*/printf( ... ); /* comments look like this; use them*/... /* anywhere blanks, tabs or newlines
couldappear */}count(buf, size)int
size, buf[ ]; {int i, c;for( i=0; i<=size; i++ )buf[i] = 0; /* set buf
tozero */while( (c=getchar( )) != '\0' ) { /* read tileof */if( c > size || c < 0 )c = size; /* fix
illegalinput */buf[c]++;}return;}
We
have already seen many examples of calling a function, so let us concentrate on
howto define one. Since
count
has
two arguments, we need to declare them, as shown,giving their types, and in the
case of
buf
,
the fact that it is an array. The declarations of arguments go between the
argument list and the opening `{'. There is no need to specifythe size of the
array
buf
,
for it is defined outside of count.The return statement simply says to go back
to the calling routine. In fact, we couldhave omitted it, since a return is
implied at the end of a function.What if we wanted
count
to
return a value, say the number of characters read? Thereturn statement allows
for this too:
int i, c, nchar;nchar = 0;...while(
(c=getchar( )) != '\0' ) {if( c > size || c < 0 )c =
size;buf[c]++;nchar++;}return(nchar);
Any
expression can appear within the parentheses. Here is a function to compute theminimum
of two integers:
min(a, b)int a, b; {return( a < b ? a : b );}
To
copy a character array, we could write the function
strcopy(s1, s2) /* copies s1 to s2 */char s1[ ], s2[ ];
{int i;for( i = 0; (s2[i] = s1[i]) != '\0'; i++ );}
As
is often the case, all the work is done by the assignment statement embedded in
thetest part of the for. Again, the declarations of the arguments s1 and s2
omit the sizes, because they don't matter to
strcopy
.
(In thesection on pointers,
we will see a moreefficient way to do a string copy.)There is a subtlety in
function usage which can trap the unsuspecting Fortran programmer. Simple
variables (not arrays) are passed in C by ``call by value'', whichmeans that
the called function is given a copy of its arguments, and doesn't know
their addresses. This makes it impossible to change the value of one of
the actual inputarguments.There are two ways out of this dilemma. One is to
make special arrangements to pass tothe function the address of a variable
instead of its value. The other is to make thevariable a global or external
variable, which is known to each function by its name
No comments:
Post a Comment