- 1. C-LANGUAGE NOTESSome words about Computer Programming
languagesNaturally a language is the source of communication
between two persons, and alsobetween 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 languagesThe 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 aprocedure one or more places. The
lists of procedural languages are as follows: C language C++
(Object Oriented) Java (Objected Oriented) Smalltalk (Objected
Oriented) Pascal language 3. 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
procedurallanguages
2. 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 languagebecause 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 programmers
platform.) in IDE you can able to write/save/open your programs
orcode, compile using short cut keys, and also perform code
debugging very easily.IDECommon Short cut Keys DescriptionF2 press
to Save current workF3 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)
3. < Global Variable (on your demand)> main () (Necessary) {
statements } < function definition> {} Remember Some common
rules for writing C programUse 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.Dont
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 the language. 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 be declared on top
# include other wise you could have an prototype error. Some header
files are as followsStdio.hConio.hDos.hString.hStdlib.hAnd many
more header files are available in Cvoid 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 4. 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:Escape DescriptionExampleSequencen Perform
line feed & Carriage return operationprintf("AnB");t Prints a
tab sequence on screenprintf ("Atb"); Prints a single quote
character on screenprintf ("a");" Prints a double quote character
on Screenprintf (""a"");r Perform carriage return operationprintf
("arb")b Remove one character from left printf ("abHi!" );Example
Program #1#include #include void main(void) { printf( " Example
Program (Escape Sequence) n"); 5. printf( "
-----------------------------------------------n"); printf( "Escape
sequnce t Meaningn"); printf( "
-------------------------------------------------n"); printf("t "
n"); printf(" t n");printf(" " t " n");printf(" n t line feed &
carriage returnn "); printf(" t t Tab characters or eigth
spacesn"); printf(" b t Erase one char from right to leftn");
printf(" r t perform only line feedn"); 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 6. r perform only line feedExample Program
#2#include #include 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 " on screen 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 data
and manipulate our data. Variables are used so that same space in
memory can hold different values at different times. In C language
following are the list of data type available through which we can
define 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 occupyint -32768 to +32767 without
fractional) 2 bytesunsigned int 0 to 65,535 2 bytes 7. 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 bytesVariablesIn 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. Forexample,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 areVariable NamesEvery 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 Cs keywords like main, while, switch etc as variable
names.Examples of legal variable names include 8. x result outfile
bestyetx1x2 out_filebest_yetpower impetusgamma hi_scoreIt is
conventional to avoid the use of capital letters in variable names.
These are used fornames of constants. Some old implementations of C
only use the first 8 characters of avariable name. Most modern ones
dont 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 VariablesLocal 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 programsfunctions. This is usually done
at the beginning of the program file, but after
preprocessordirectives. The variable is not declared again in the
body of the functions which access it.Static VariablesAnother 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.ConstantsA 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.
9. 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 cant 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
OperatorsOne 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 ofvalues, combination of logical states, and
manipulation of individual binary digits. Thebinary 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 Arithmetic operators
Type conversion Comparison Logical Connectors 10. Assignment
StatementThe 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 likey = (m * x) + cThis
assignment will save the value of the expression invariable y.
Arithmetic operatorsHere 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 anotherexpression. 11. 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
belowComparisonC has no special type to represent logical or
boolean values. It improvises by using any ofthe 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 != cIn the last example,
all arithmetic is done before any comparison is made. 12. 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 ConnectorsThese are the usual And, Or and Not
operators.They are frequently used to combine relational operators,
for examplex < 20 && x >= 10In 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 StatementsA 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 in
variables. 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 canbe used to write powerful programs by; Repeating important
sections of the program. Selecting between optional sections of a
program. 13. The if else StatementThis 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 45if (result >=
45)printf("Passn");elseprintf("Failn");It is possible to use the if
part without the else.if (temperature < 0)print("Frozenn");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("Passedn");printf("Congratulationsn")}else{
printf("Failedn");printf("Good luck in the resitsn");}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 An");else if
(result >= 60)printf("Passed: Grade Bn");else if (result >=
45)printf("Passed: Grade Cn");elseprintf("Failedn");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 canbe used with more or
fewer else ifs, and the final lone else may be left out. It is up
to theprogrammer to devise the correct structure for each
programming problem. 14. The switch StatementThis 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 integerinto 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("Nonen");
break;case 1 : printf("Onen"); break;case 2 : printf("Twon");
break;case 3 :case 4 :case 5 : printf("Severaln"); break;default :
printf("Manyn"); 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 ofnumber.Both if and switch
constructs allow the programmer to make a selection from a numberof
possible actions.The other main type of control statement is the
loop. Loops allow a statement, or block ofstatements, to be
repeated. Computers are very good at repeating simple tasks
manytimes, the loop is Cs way of achieving this.Loops 15. 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 times the 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 fixed number of times. It is very flexible, and novice
programmers should take care not to abuse the power it offers.The
while LoopThe 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 isnt null, the index is incremented
and the test is repeated.The do while LoopThis is very similar to
the while loop except that the test occurs at the end of the
loopbody. 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 loopsback 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) 16. The for LoopThe 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 orrunning
increment. A blank comparison statement will always be treated as
true. This willcause the loop to run indefinitely unless
interrupted by some other means. This might bea 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 StatementWe 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. 17. 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
beprotected within an if statement which provides the test to
control the exit condition.The continue StatementThis 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 StatementC has a goto statement which permits
unstructured jumps to be made. Its use is notrecommended, so well
not teach it here. Consult your textbook for details of its
use.Pointers in CPointers are not exclusive to functions, but this
seems a good place to introduce thepointer type.Imagine that we
have an int called i. Its address could be represented by the
symbol &i. Ifthe 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 ofits 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 ofuse, known as de-referencing
pi, would bei = *pi;Take care not to confuse the many uses of the *
sign; Multiplication, pointer declarationand pointer
de-referencing. 18. 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 = %dn", x, *y);x ++;(*y)++;printf("Finishing fiddle: x = %d, y =
%dn", 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 = %dn", i, j); printf("Calling fiddle nown");.
fiddle(i, &j); printf("Returned from fiddlen");
printf("Finishing main : i = %d, j = %dn", 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 now Starting
fiddle: x =0, y =0Finishing fiddle: x =1, y =1Returned from
fiddleFinishing main : i = 0, j =1After the return from fiddle the
value of i is unchanged while j, which was passed as apointer, 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 isnt modified, the value can be passed without
anyworries about pointers. 19. The Standard Input Output FileUNIX
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,
yourprogram must include these definitions by adding the line This
is done by adding the line#include near the start of the program
file.If you do not do this, the compiler may complain about
undefined functions or datatypes.Formatted Input / OutputWe have
met these functions earlier in the course. They are closest to the
facilities offeredby Pascal or Fortran, and usually the easiest to
use for input and output. The versionsoffered under C are a little
more detailed, offering precise control of layout. printf
scanfprintfThis 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 forentries
in the control string.There are several more types available. For
full details typeman printfon your UNIX system.It is also possible
to insert numbers into the control string to control field widths
forvalues 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
- 20. before the format information, for example %-6d, a decimal
integer right justified in a 6space field.scanfscanf 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 OutputWhere 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 putsgetsgets 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.putsputs 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 main(){ char line[256]; /*
Define string sufficiently large to 21. 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.ArraysIn 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 = %dn", 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( ) { 22. 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++;}
}StringsText 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 `0because most programs
that manipulate character arrays expect it. For example, printfuses
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, its 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
characterarray 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 23. 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 size || c < 0 )c = size; buf[c]++; nchar++; }
return(nchar); 24. 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 functionstrcopy(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 dont matter to strcopy. (In the section 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 Fortranprogrammer. 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 doesnt know theiraddresses.
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