ANSI C Programming Reference

8/3/2019 ANSI C Programming Reference

1/44

ANSI C Programming Reference.


2/44

ANSI C Programming Reference Chapter 0:

1


3/44


2

Table of Contents

1. C KEYWORD OVERVIEW........................................................................................................................5

2. DATA TYPE KEYWORDS ........................................................................................................................6

2.1. Variable declaration 6

2.2. int - data type 6

2.3. float - data type 6

2.4. double - data type 6

2.5. char - data type 6

2.6. Modifiers - short, long, signed, unsigned 6

2.7. void - data type. 7

2.8. enum - data type 7

2.9. const - qualifier 82.10. volatile - qualifier. 8

2.11. Data type conversion 8

2.12. Cast, typecasting 8

2.13. The sizeof operator 9

3. FLOW CONTROL KEYWORDS...............................................................................................................9

3.1. The break keyword 9

3.2. The case, switch and default keywords 9

3.3. The continue keyword 10

3.4. The if and else keywords 11

3.5. The goto keyword. 12

3.6. The return keyword 12

3.7. Return with status: the exit function 13

4. LOOP CONTROL KEYWORDS .............................................................................................................13

4.1. Iteration vs Recursion 13

4.2. The do keyword 13

4.3. The for keyword. 14

4.4. The while keyword. 15

5. THE STRUCT KEYWORD......................................................................................................................16

5.1. Structure basics 16

5.2. Structure membership 165.3. Pointers to structures 17

6. STORAGE CLASS KEYWORDS............................................................................................................18

6.1. auto - Storage Class 18

6.2. register - Storage Class 18

6.3. static - Storage Class 18

6.4. extern - Storage Class 19

6.5. The typedef keyword. 19

6.6. The union keyword. 20


4/44


3

7. PROGRAM ELEMENTS AND STRUCTURE .........................................................................................20

7.1. Statements 20

7.2. Blocks 20

7.3. Comments. 21

7.4. C Compiler Preprocessors, # 21

7.5. Macros 22

7.6. Local variables 22

7.7. Global variables 22

8. FUNCTIONS AND PASSING ARGUMENTS..........................................................................................23

8.1. Function Basics. 23

8.2. Declaration. 23

8.3. Definition. 23

8.4. Passing values. 24

8.5. Passing pointers. 24

8.6. Passing Arrays. 24

8.7. Returning values. 25

8.8. Returning pointers. 25

9. OPERATORS AND EXPRESSIONS.......................................................................................................25

9.1. Arithmetic 25

9.2. Assignment 26

9.3. Logical/Relational 26

9.4. Bitwise 26

9.5. Odds and ends! 26

9.6. true or false. 26

9.7. Confusion of == and = in IF statements 27

9.8. Idioms 27

9.9. 279.9. Operator Precedence 27

10. BITWISE OPERATIONS.........................................................................................................................1

10.1. AND OR and XOR 1

10.2. One's Complement 30

10.3. Bit shift. 30

11. CONSTANTS ........................................................................................................................................30

11.1. Integer constants. 30

11.2. Floating point constants. 31

11.3. Chararacter constants. 31

11.4. String constants. 31

12. ARRAYS................................................................................................................................................31

12.1. int and float arrays 31

12.2. Two dimensional int and float arrays. 32

12.3. char arrays. 32

12.4. Two dimensional char arrays. 33


5/44


4

13. POINTERS. ...........................................................................................................................................33

13.1. First Principles. 33

13.2. Pointer definition. 34

13.3. Pointers to arrays 35

13.4. Char Arrays versus Char pointers 35

13.5. Void Pointers 36

13.6. Pointers to functions 36

13.7. Linked Lists 36

13.8. The malloc function 37

14. STRINGS AND CHARACTERS............................................................................................................37

14.1. Pointers to strings. 38

14.2. printf, sprintf, fprintf, scanf format identifiers. 38

14.3. Escape sequences. 39

14.4. Ascii character table in Hex. 40

15. FUNCTIONS SUMMARY......................................................................................................................40

15.1. ANSI standard libraries. 4015.2. ctype.h 40

15.3. math.h 41

15.4. stdio.h 41

15.5. stdlib.h 41

15.6. string.h 41

15.7. time.h 42

16. C PROGRAMMING EXAMPLES ..........................................................................................................42

17. GLOSSARY OF C TERMS. ..................................................................................................................43


6/44


5

1. C Keyword Overview

The following list shows all the ANSI defined C keywords. I have included sizeofbecause it looks like a keyword.

Keyword Chapter Section Page

auto Storage Class Keyword 6.1 19

break Flow Control Keywords 3.1 10

case Flow Control Keywords 3.2 10

char Data Type Keywords 2.5 6

const Data Type Keywords 2.9 8

continue Flow Control Keywords 3.3 11

default Flow Control Keywords 3.2 10

do Loop Control Keywords 4.2 14

double Data Type Keywords 2.4 6

else Flow Control Keywords 3.4 11

enum Data Type Keywords 2.8 7

extern Storage Class Keyword 6.4 20

float Data Type Keywords 2.3 6

for Loop Control Keywords 4.3 14

goto Flow Control Keywords 3.5 12

if Flow Control Keywords 3.4 11

int Data Type Keywords 2.2 6

long Data Type Keywords - Modifiers 2.6 6

register Storage Class Keyword 6.2 19

return Flow Control Keywords 3.6 13short Data Type Keywords - Modifiers 2.6 6

signed Data Type Keywords - Modifiers 2.6 6

sizeof Data Type Keywords 2.13 9

static Storage Class Keyword 6.3 19

struct The STRUCT Keyword 5 16

switch Flow Control Keywords 3.2 10

typedef Storage Class Keyword 6.5 20

union Storage Class Keyword 6.6 20

unsigned Data Type Keywords - Modifiers 2.6 6

void Data Type Keywords 2.7 7volatile Data Type Keywords 2.10 8

while Loop Control Keywords 4.4 16


7/44


6

2. Data Type Keywords

2.1. Variable declaration

C has a concept of 'data types' which are used to declare a variable before its use. The declaration assigns storage forthe variable and defines the type of data that will be held in the location.

int float double char void enum

Please note that there is not a boolean data type. C does not have the traditional view about logical comparison, but

thats another story.

2.2. int - data typeint is used to define integer numbers.

{ int Count;Count = 5;

}

2.3. float - data typefloat is used to define floating point numbers.

{float Miles;Miles = 5.6;

}

2.4. double - data typedouble is used to define BIG floating point numbers. It reserves twice the storage for the number. On PCs this is

likely to be 8 bytes.

{double Atoms;Atoms = 2500000;

}

2.5. char - data typechar defines characters.

{char Letter;

Letter = 'x';}

2.6. Modifiers - short, long, signed, unsignedThe above data types have the following modifiers:

short long signed unsigned

The modifiers define the amount of storage allocated to the variable. The amount of storage allocated is not cast in

stone. ANSI has the following rules:

What this means is that a 'short int' should assign less than or the same amount of storage as an 'int' and the 'int'

should be less bytes than a 'long int'.What this means in the real world is:

short int


8/44


7

These figures only apply to todays generation of PCs. Mainframes and midrange machines could use different

figures, but would still comply with the rule above.

You can find out how much storage is allocated to a data type by using the sizeofoperator.

2.7. void - data type.The voidkeyword allows us to create functions that either do not require any parameters or do not return a value.

The following example shows a function that does not return a value.

The next example shows a function that does not require any parameters:

2.8. enum - data typeenum is closely related to the #define preprocessor.

It allows you to define a list of aliases which represent integer numbers. For example if you find yourself coding

something like:#define MON 1

#define TUE 2#define WED 3

You could use enum as below.

enum week { Mon=1, Tue, Wed, Thu, Fri Sat, Sun} days;or

enum boolean { FALSE = 0, TRUE };

An advantage ofenum over#define is that it has scope This means that the variable (just like any other) is only

visible within the block it was declared within.

Note:

If a variable is defined with enum it is considered by the compiler to be an integer, and can have ANY integer

value assigned to it, it is not restericted to the values in the enum statement.

See Also:#define preprocessor.

Example:/* This program will compile but the #define statement

* will cause FALSE and TRUE to have a value of 1*/

enum Boolean_t {FALSE=0, TRUE} Boolean;

#define FALSE 1

main()

{enum Boolean_t Boolean;

printf("False has a value of %d\n", FALSE);

printf(" True has a value of %d\n", TRUE);

short int - 2 bytes (16 bits)int int - 2 bytes (16 bits)long int - 4 bytes (32 bits)

signed char - 1 byte (Range -128 ... +127)unsigned char - 1 byte (Range 0 ... 255)

float - 4 bytesdouble - 8 bytes

long double - 8 bytes

void Print_Square(int Number){

printf("%d squared is %d\n",Number, Number*Number);}

int Random(void){

srand((unsigned int)time((time_t *)NULL));return( rand());

}


9/44


8

}

/*************** Resulting printout: ******************/

False has a value of 1

True has a value of 1

2.9. const - qualifier

The const qualifier is used to tell C that the variable value can not change after initialisation. For example:const float pi=3.14159;

pi cannot be changed at a later time within the program.

Another way to define constants is with the #define preprocessor which has the advantage that it does not use any

storage (but who counts bytes these days?).

2.10. volatile - qualifier.The volatilekeyword acts as a data type qualifier. volatile means the storage is likely to change at anytime and be

changed but something outside the control of the user program. This means that if you reference the variable, the

program should always check the physical address (ie a mapped input fifo), and not use it in a cashed way.

Examples

Between reads the bytes are changed in the latch.Without the volatile, the compiler optimises this to a single

assignment:lsb = middle = msb = *handle->baseAddr;

2)

A volatile variable is for dynamic use. E.G. for data that is to be passed to an I/O port Here is an example.#define TTYPORT 0x17755U

volatile char *port17 = (char)*TTYPORT;*port17 = 'o';*port17 = 'N';

Without the volatile modifier, the compiler would think that the statement *port17 = 'o'; is redundant and

would remove it from the object code. The volatile statement prevents the compiler optimisation.

See also:Data type conversion - Storage classes. - cast - typedefkeyword.

2.11. Data type conversionAn operatormust have operands of the same type before it can carry out the operation. Because of this, C will

perform some automatic conversion ofdata types.

These are the general rules for binary operators (* + / % etc):

If either operand is long double the other is converted to long double.

Otherwise, if either operand is double the other is converted to double

Otherwise, if either operand is float the other is converted to float

Otherwise, convert char and short to int

Then, if an operand is long convert the other to long.

2.12. Cast, typecastingIf you want to change the datatype of a variable you have to use a technic called cast. For example if want to change

an int to a float you could use the following syntax:

1) /* Base address of the data input latch */

volatile unsigned char *baseAddr;

/* read parts of output latch */

lsb = *handle->baseAddr;middle = *handle->baseAddr;msb = *handle->baseAddr;


10/44


9

main(){int var1;float var2;

var2 = (float)var1;}

As it happens this example would never be used in practice because C would perform the conversion automatically.

What this example does show is the cast operator() . This states, the result of the expression (in this case var1) is tobe a data type offloat.

See Alsotypedefkeyword.

2.13. The sizeof operatorsizeofwill return the number of bytes reserved for a variable ordata type.

The following code shows sizeofreturning the length of a data type.

/* How big is an int? expect an answer of 4. */main(){

printf("%d \n", sizeof(int));}

sizeofwill also return the number of bytes reserved for a structure or an array.

/**** Purpose: Find out the size of the different data objects ****/

#include

main()

{

char array[10];

struct s {

int a;

float b;

} structure;

.....

printf(" array is %i\n", sizeof array);

printf(" struct is %i\n", sizeof structure);

}

/**************** Resulting printout ************************

array is 10

struct is 8

See also:

The strlen function Otheroperators malloc function.

3. Flow Control Keywords

3.1. The break keywordThis statement allows the program to escape from a for, while, do ... while, ifblock orswitch structures. Ref

examples undercase-switch for illustration of it's use.

3.2. The case, switch and default keywordsThe switch-case statement is a multi-way decision statement. Unlike the multiple decision statement that can be

created using if-else, the switch statement evaluates the conditional expression and tests it against numerous constant


11/44


10

values. The branch corresponding to the value that the expression matches is taken during execution.

The value of the expressions in a switch-case statement must be an ordinal type i.e. integer, char, short, long, etc.

Float and double are not allowed. The syntax is :

switch( expression ){case constant-expression1: statements1;[case constant-expression2: statements2;][case constant-expression3: statements3;]

[default : statements4;]}

The case statements and the default statement can occur in any order in the switch statement. The default clause is

an optional clause that is matched if none of the constants in the case statements can be matched. Consider the next

example:

switch( Grade ){case 'A' : printf( "Excellent" );case 'B' : printf( "Good" );case 'C' : printf( "OK" );case 'D' : printf( "Mmmmm...." );case 'F' : printf( "You must do better than this" );default : printf( "What is your grade anyway?" );}

Here, if the Grade is 'A' then the output will be:ExcellentGoodOKMmmmm....You must do better than thisWhat is your grade anyway?

This is because, in the 'C' switch statement, execution continues on into the next case clause if it is not explicitly

specified that the execution should exit the switch statement. The correct statement would be:

switch( Grade ){case 'A' : printf( "Excellent" );

break;

case 'B' : printf( "Good" );break;

case 'C' : printf( "OK" );break;

case 'D' : printf( "Mmmmm...." );break;

case 'F' : printf( "You must do better than this" );break;

default : printf( "What is your grade anyway?" );break;

}

Although the breakin the default clause (or in general, after the last clause) is not necessary, it is goodprogramming practice to put it in anyway.

3.3. The continue keywordcontinue allows a new iteration of a loop without the current iteration completing. For example you could filter

records from a file with the continue statement. continue is related to thebreakstatement. The following example

illustrates it's use:

/* To filter some records. Demonstrates 'continue', 'feof' & 'fgets' */

#include

main(){

char data[80]; /* Record read from the file. */

FILE *ptr; /* Pointer to the file. FILE is a

structure defined in */


12/44


11

/* Open the file - no error checking done */

ptr = fopen("/etc/hosts","r");

/* Read one record at a time, checking

for the End of File. EOF is defined

in as -1 */

while (feof(ptr) == 0)

{

fgets(data, 80, ptr); /* Read next record */

if (data[0] == '#') continue; /* filter out the comments */

printf("%s",data); /* O/P the record to the screen */

}

fclose(ptr); /* Close the file. */

}

3.4. The if and else keywordsThe if-else statement is a two-way decision statement. It is written as

The else portion is optional. If the expression evaluates to true (anything other than 0) then statement1 is executed. Ifthere is an else statement and the expression evaluates to false statement2 is executed. For example(1)

int NumberOfUsers;.....if( NumberOfUsers == 25 ){ /* No else part */printf( "There are already enough users. Try later.\n" );return ERROR;}

.....(2)

if( a >= b ) larger = a; /* else part is present */else larger = b;

Consider this code fragment:if( p == 1 )if( q == 2 ) r = p * 2 + q;

else r = q * 2 + p;

Because the else part is optional, there is an ambiguity when an else is omitted from a nested if sequence. In 'C', this

is resolved by associating the else with the closest previous if that does not have an else. Therefore, in the above

example, the else part belongs to the if(q==2) statement. The code can be made more readable by explicitly putting

parentheses in the expression, like this:

if( p == 1 ){if( q == 2 ) r = p * 2 + q;}

else r = q * 2 + p;OR

if( p == 1 ){if( q == 2 ) r = p * 2 + q;else r = q * 2 + p;}

Because the statement in the else part can also be an if statement, a construct such as shown below is possible in 'C'

to create a multiple choice construct.

if( expression1 )statement1;

else if( expression2 )statement2;

else if( expression3 )statement3;

.....elsestatementN;

if ( expression ) statement1;[else statement2;]


13/44


12

3.5. The goto keyword.Well, I have resisted adding goto for a whole year. But tonight I have had a couple of beers and I am ready to go for

it. It must be said that most programmers will claim that goto is never required and I dont have reason to disagree,

but you may like to differ. The syntax is:

goto lab1;

lab1:

goto allows the program to 'jump' to a named label, in this case lab1, the target label MUST be terminated with a :

(colon).

Example./* A division checking for divide by zero demonstrates the goto statement.*/

#include

main()

{

char data[100];

double num1, num2;

printf(" Please enter a number ==> " );

gets(data);

num1 = atof(data);

printf(" Please enter a number ==> " );

gets(data);

num2 = atof(data);

/* Stop a divide by zero with the goto statement. */

if ( num2 == 0.0 ) goto end_prog;

printf(" %4.2f divided by %4.2f is %4.2f\n", num1, num2, num1/num2);

end_prog:

printf(" Program ended\n");

}

3.6. The return keywordreturn will return a value from a function to its caller. The value is the result of an expression.

As an Example, this will print 7:

int func(void);

main(){

printf("%d \n", func());}int func(void){

return 7;}

What ever follows the return statement will be evaluated as an expression. So, to be consistant you should place

brackets around the return value.

return(7);

Or you could evaluate a formula on the statement:return (Count-1);

Finally, if the function returns a void the return statement is not required, but maybe needed to leave a functionbefore the end of the function block. Here is an example.

void CheckDate(int)

main()


14/44


13

{CheckDate(40)

}

void CheckDate(int Month){if (Month > 31){return;

}puts("Month is valid");

}

3.7. Return with status: the exit functionexit causes the program to end and supplies a status code to the calling environment.

Library: stdlib.hPrototype: void exit(int status);Syntax:

main(){exit(0); /* Clean exit */

}

4. Loop Control Keywords

4.1. Iteration vs RecursionMost problems that can be solved with iteration ( for, while, do loops) can also be solved with recursion. Pros and

cons are:

Iteration code will be faster and will use less resources.

Recursion normaly looks more like the original formula.

Anyway up, as an example of both technics here is some code to give the factorial of a number:#include

int factorial(int num);

main()

{

int num;

puts ("This program will return the factorial of a number.");

printf("Please enter the number ==> " );

scanf("%d", &num);

printf(" %d! is %d\n",num, factorial(num) );

}

int factorial(int num) /* Iteration */{

int count, ans=1;

for (count=1; count


15/44


14

do{printf(" i is %d\n", i);

}while(--i);

}

The program result will look like this:

The main difference between do and while is the time that expression is evaluated.

do performs the first test AFTER the first iteration. 'do...while' works like 'repeat ...until' in Pascal.

while performs the first test BEFORE the first iteration.

4.3. The for keyword.The forkeyword is used to repeat a block of code many times.

Basic principlesSay you wanted to print all the numbers between 1 and 5, you could write:

main(){int count=1;printf("%d\n", count++);printf("%d\n", count++);printf("%d\n", count++);printf("%d\n", count++);printf("%d\n", count++);}

As you can see this program would NOT be very practical if we wanted 500 numbers. The problem can be solved

with the for statement as below.

main()

{int count;

for ( count=1 ; count


16/44


15

for (expression_1 ; expression_2 ; expression_3) statement ;

1.Execute expression_1.

2.Evaluate expression_2, AND, if TRUE proceed; if FALSE exit the loop.

3.Execute statement.

4.Execute expression_3.

5.Repeat step 2.

Any of the three expressions can be missing; if the first or third is missing, it is ignored.

Ifexpression_2 is missing, it is assumed to be TRUE.

Note, however, that both semicolons (;) are required. Also, be aware that statementmay NEVER be executed

as it is possible expression_2 will be FALSE the first time it is evaluated.

Another way to think of a basic for loop is as:

expression_1;while (expression_2){

statement(s);

expression_3;}

The following example is an infinite loop:main(){

for( ; ; ) puts(" Linux rules!");}

4.4. The while keyword.The while keyword is related to do and for. Its purpose is to repeatedly execute ablockof statements, for example :

main(){

int i=5;

while(--i){printf(" i is %d\n", i);}

}

The expression i-- is evaluated and if its true the statements in theblockare executed. The loop continues until the

expression is false (zero). The result will look like this:i is 4i is 3i is 2i is 1

It is important to note that the statements on a while will not get executed if the first evaluation of the expression is

FALSE. If you do not want this to happen you may prefer to use the do statement. Now consider the next example:

main(){int i=5;

while(--i);{printf(" i is %d\n", i);}

}

The result will look like this:

i is 0

This is because of the ; at the end of the while statement which means the while will loop (executing NULLstatements) until i is zero. Execution will then continue down the program (to the printf).


17/44


16

See also:breakkeyword - continue keyword.

5. The struct keyword

5.1. Structure basicsstruct is used to declare a new data-type. Basically this means grouping variables together. For example, a struct

data type could be used to declare the format of the following file.

Jo Loss Maths AHarry Carpenter English ABilly King Maths C

The records above could be described in a struct as follows:

struct {char cname[8];char sname[16];char exam[16];char grade;} record;

The statement above declare a variable called record with 4 members called cname, sname, exam, grade. The

structure as a whole can be referred to as record and a member can be referenced as record.exam. Structures can be

declared in various forms...

struct x {int a; int b; int c;}; /* declaration */struct {int a; int b; int c;} z;struct x z;

All the examples above are structure declarations,

The first gives x as a 'structure tag' - this is optional. The first and second declare the members of the structure.

Second and third give z this is the variable that assumes thestructure type.

5.2. Structure membershipWe can access individual members of a structure with the . operator. For example to assign a value, we can enter:

struct x {int a; int b; int c;};

main(){

struct x z;

z.a = 10;z.b = 20;z.c = 30;

}

And to retrieve a value from a structure member:struct x {int a; int b; int c;} ;

main(){struct x z;

z.a = 10;z.a++;printf(" first member is %d \n", z.a);

}


18/44


17

5.3. Pointers to structuresAll that we have discussed so far has been OK but runs into problems when structures have to be moved between

functions for the following reasons:

If the structure is large it is more efficient to pass a pointer to the structure instead of the structure its self. This

technic is also used to pass pointers to arrays between functions.

When passing a structure to a function, you actually pass a COPY of the structure. Therefore it is not possible to

change the values of members within the structure as the copy is destroyed when the function ends.

So how does it all work? Here is an example.

struct x {int a; int b; int c;} ; | struct x {int a; int b; int c;} ;void function(struct x); | void function(struct x *);

|main() | main(){ | {struct x z; | struct x z, *pz; /* 3 */

| pz = &z; /* 4 */z.a = 10; /* 1 */ | z.a = 10;z.a++; | z.a++;

|function(z); /* 2 */ | function(pz); /* 5 */

} | }void function( struct x z) | void function(struct x * pz){ | { /* 6 */printf(" first member %d \n", z.a); | printf(" first member %d \n", (*pz).a);

} | }

Here is the annotation.

1.Give a structure member a value.

2.Pass a COPY of the whole structure to the function.

3.Define 'pz' a pointer to a structure of type 'x'.

4.Put the address of 'z' into 'pz'. 'pz' now POINTS to 'z'. PLEASE NOTE. 'z' is defined to reserve memory equal to

the size of the structure. 'pz' only holds an address so will be 4 bytes long.

5.Pass the pointer into the function.

6.Print the value of the member 'a'.

The (*pz).a syntax is used a great deal in C and it was decided to create ashort hand for it. So:

(*pz).a == pz->a

Here is the final picture:

struct x {int a; int b; int c;} ; /* Declare the structure.*/

void function(struct x * ); /* Declare the function. */

main(){

/* Declare two variables: *z == type struct xand * pz == a pointer to type struct x */

struct x z, *pz;

pz = &z; /* put the address of 'z' into 'pz' */z.a = 10; /* initialize z.a */z.a++; /* Increment z.a */

/* print the contents of 'z.a' using the pointer 'pz'*/printf(" first member before the function call %d \n", pz->a);

/* Call 'function' passing the pointer 'pz' */function(pz);

/* Print NEW value of 'z.a' using three different notations */

printf(" first member after the function call %d \n", pz->a);printf(" first member after the function call %d \n", (*pz).a);printf(" first member after the function call %d \n", z.a);

}


19/44


18

void function(struct x * pz){

/* Print the value of 'z.a' by referencing the pointer 'pz'which holds the address of 'z' */

printf(" first member inside the function %d \n", pz->a);

/* Increment the value of 'z.a' at the source location in memory. */pz->a++;

}

See Also:typedef keyword. - Linked lists.

6. Storage Class Keywords

C has a concept of 'Storage classes' which are used to define the scope (visibility) and life time of variables and/or

functions. So what Storage Classes are available?

auto register static extern typedef

6.1. auto - Storage Classauto is the default storage class for local variables.

{int Count;auto int Month;

}

The example above defines two variables with the same storage class. auto can only be used within functions, i.e.

local variables.

6.2. register - Storage Classregister is used to define local variables that should be stored in a register instead of RAM. This means that the

variable has a maximum size equal to the register size (usually one word) and cant have the unary '&' operator

applied to it (as it does not have a memory location).{register int Miles;

}

Register should only be used for variables that require quick access - such as counters. It should also be noted that

defining 'register' does not mean that the variable will be stored in a register. It means that it mightbe stored in a

register - depending on hardware and implementation restrictions.

6.3. static - Storage Classstatic is the default storage class for global variables. The two variables below (count and road) both have a staticstorage class.

static int Count;int Road;

{printf("%d\n", Road);

}

static variables can be 'seen' within all functions in this source file. At link time, the static variables defined here will

not be seen by the object modules that are brought in.

'static' can also be defined within a function! If this is done the variable is initalised at run time but is not reinitalized

when the function is called. This is serious stuff - tread with care.

{ static Count=1;}

There is one very important use for 'static'. Consider this bit of code.char * func(void);


20/44


19

main(){char *Text1;Text1 = func();

}

char * func(void){

char Text2[10]="martin";return(Text2);

}

Now, 'func' returns a pointer to the memory location where 'text2' starts BUT text2 has a storage class of 'auto' and

will disappear when we exit the function and could be overwritten by something else. The answer is to specify

static char Text[10]="martin";

The storage assigned to 'text2' will thus remain reserved for the duration if the program.

6.4. extern - Storage Classextern defines a global variable that is visible to ALL object modules (e.g. Source 1 and Source 2 below). When you

use 'extern' the variable cannot be initalized as all it does is point the variable name at a storage location that has

been previously defined.

Source 1 | Source 2-------- | --------extern int count; | int count=5;

|write() | main(){ | {printf("count is %d\n", count); | write();

} | }

Count in 'source 1' will have a value of 5. If source 1 changes the value of count - source 2 will see the new value.

6.5. The typedef keyword.

Every variable has a data type. typedefis used to define new data type names to make a program more readable tothe programmer. For example:

These examples are EXACTLY the same to the compiler. But the right hand example tells the programmer the type

of money he is dealing with. A common use for typedef is to define a boolean data type:

typedef enum {False=0, TRUE} Boolean

main (){

Boolean flag = TRUE;}

And as a final example, how about creating a string datatype?

The main use for typedef seems to be when defining structures. For example:

Take care to note that person is now a type specifier and NOT a variable name.

I would expect to see 'typedef' in header files.

|main() | main(){ | {int money; | typedef int Pounds;money = 2; | Pounds money = 2

} | }

typedef char * String;

main(){String Text = "Thunderbird";

printf("%s\n", Text);}

typedef struct {int age; char *name} person;

person people;


21/44


20

6.6. The union keyword.The unionkeyword allows several variables of different type and size to occupy the same storage location.The

syntax to define a union is simular to the struct keyword as shown below:union union_def { int a; float b; char c;} ;

and a variable declared with either of these statements:

union union_def union_var;union { int a; float b; char c;} union_var;

If you wish to initalise a variable you can say:

union { int a; float b; char c;} union_var=97;

By default the first variable (a) is initalised. To assign a value to a variable you can say:

union_var.b=99.99;union_var.a=34;union_var.c='x';

It's important to note that the storage will only hold ONE value, looking at the three lines above, union_var.a

overwrites union_var.b and then union_var.c overwrites union_var.a

I have yet to see more than one use for this keyword.

See Also:Data types.

7. Program Elements and Structure

7.1. Statements

C has three types of statement.

assignment

=

selection (branching)if (expression)elseswitch

iteration (looping)

7.2. BlocksThese statements are grouped into blocks, a block is identified by curly brackets.There are two types of block.

statement blocks

if ( i == j){printf("martin \n");

}

Thestatement blockcontaining the printfis only executed if the i == jexpression evaluates to TRUE.

function blocksint add( int a, int b) /* Function definition */{int c;c = a + b;return c;

}

The statements in this block will only be executed if the addfunction is called.

while (expression)(expression;expression;expression)do {block}


22/44


21

7.3. Comments.Lets start with a few examples.

main(){int Counter=0; /* Initalise Counter */

/* a comment */

/** Another comment*/

/******************* Final comment.******************/

}

A comment starts with a /* and ends with */. Comments started in this way can span multiple lines but cannot be

nested!! For example:

main()

{int Count = 0; /* Initalise

* Counter to 0 *//* /* Invalid comment */ */

}

This will give a syntax error, since comments within comments are illegal.

Warning!: C++ notationC++ allows // as an inline comment, it can be used on any line and is delimited by the newline character (return).

Many C-compilers, however, do not allow this.

main(){int Counter = 0; // Initalise Counter.

/* Start the main processing here. */}

7.4. C Compiler Preprocessors, #Preprocessor commands are executed before the compiler compiles the source code. These commands will change

the original code usually to suit the operating environment and/or to add code that will be required by calls to library

functions. Preprocessors are recognised by the leading # in their names, as listed below:

#include Insert a source file.

#define Define a preprocessor constant.

#ifBranch based on an expression.#ifdefBranch if preprocessor constant has been defined?

#ifndefBranch is a preprocessor constant has NOT been defined.

#line Specify the number of the next source line.

#undefRemove a preprocessor constant.

#pragma Perform an implementation dependent action???

#else Executed if #if #ifdef or #ifndef fails.

#error Write an error message.

#elifExecuted when an #if fails.

#endifClose #if #ifdef or #ifndef

Note: Preprocessors should start in column 1.


23/44


22

7.5. MacrosMacros are built on the #define preprocessor.

Normally a #define would look like:#define PI 3.142

But, a macro would look like this.

#define SQUARE(x) x*x

The main difference is that the first example is a constant and the second is an expression. If the macro above was

used in some code it may look like this:

#define SQUARE(x) x*x

main(){int value=3;printf("%d \n", SQUARE(value));

}

After preprocessing the code would become:main()

{ int value=3;printf("%d \n", value*value);

}

Notes:

The value passed to SQUARE could have been an intfloat ordouble

Long macros can span multiple lines by using a followed by a newline (return).

7.6. Local variablesLocal variables must always be defined at the top of a block. When a local variable is defined - it is not initalised by

the system, you must initalise it yourself. A local variable is defined inside a blockand is only visable from withinthe block.

main(){int i=4;i++;

}

When execution of the block starts the variable is available, and when the block ends the variable 'dies'. A local

variable is visible within nested blocks unless a variable with the same name is defined within the nested block.main(){int i=4;int j=10;i++;

if (j > 0){printf("i is %d\n",i); /* i defined in 'main' can be seen */

}if (j > 0){int i=100; /* 'i' defined in and local to this block */printf("i is %d\n",i);

} /* 'i' (value 100) dies here */printf("i is %d\n",i); /* 'i' (value 5) is now visible. */

}

7.7. Global variables

Global variables ARE initalised by the system when you define them!int == 0char == \0float == 0pointer == NULL


24/44


23

In this example i is a global variable, it can be seen and modified by main and any other functions that may

reference it.

int i=4;main(){i++;

}

Now, this example hasglobalandInternalvariables.int i=4; /* Global definition */main(){i++; /* global variable */func

}

func(){int i=10; /* Internal declaration */i++; /* Internal variable */

}

i in main is global and will be incremented to 5. i infunc is internal and will be incremented to 11. When controlreturns to main the internal variable will die and and any reference to i will be to the global.

See Also:See Storage classes to see the more powerful features of variable declarations.

8. Functions and Passing Arguments.

A function is a block of code that can be executed many times by other functions, or itself.

Function basics.

Declaration.

Definition.

Passing values.

Passing pointers.

Passing Arrays.

Returning values.

Returning pointers.

8.1. Function Basics.You should already understand the concept of functions! If you don't, you are a sad sad man....

P.S. main() is a function.

8.2. Declaration.Just like variables, all functions have to be declared before use. Here is an example.

int add( int, int);

This statement declares a function called add, it has two integer arguments and returns an integer.

8.3. Definition.The definition is the meat of the function. Here's an example.

int add( int, int); /* Function declaration */

main(){


25/44


24

int i=1;printf("i starts out life as %d.", i);i = add(1, 1); /* Function call */

printf(" And becomes %d after function is executed.\n", i);

}

int add( int a, int b) /* Function definition */{

int c;c = a + b;return c;}

8.4. Passing values.Passing values is known as call by value. You actually pass a copy of the variable to the function. If the function

modifies the copy, the original remains unaltered. The previous example demonstarted call by value

8.5. Passing pointers.This is known as call by reference and is an area worth spending some time on. We do not pass the data to the

function, instead we pass a pointer to the data. This means that if the function alters the data, the original is altered.

void add(int*); /* Function declaration */

main()

{

int i=4; /* variable declaration */

int* ptr; /* int pointer */

ptr = &i; /* 'ptr' now contains the address of 'i'*/

printf("i starts out life as %d.\n", i);

printf(" *ptr is %d.\n", *ptr);

add(ptr); /* Function call */

printf(" i is now %d.\n", i);

}

void add(int *ptr) /* Function definition */

{

++*ptr; /* Add 1 to the value pointed too by 'ptr' */

return;

}

8.6. Passing Arrays./* (1) Demonstrate passing a pointer to an array to a function.*/

#define I_SIZE 2

void add(int*); /* Function declaration */

main()

{

int i[I_SIZE]={4,6}; /* array declaration */

int count=0;

for (count=0;count


26/44


25

++*ptr; /* Add 1 to the first element in the array */

++*(ptr+1); /* And the second element */

return;

}

/* (2) Demonstrate passing a pointer to a character string to a function. */

int function1(char * array);

main()

{

char array1[10]="987654321"; /* one less so the \0 will fit */

function1(array1); /* call function */

printf("%s\n", array1); /* O/P the altered array. '5' will

* have been changed to 'x' */

}

function1(char * array)

{printf("%s\n", array); /* printf expects a pointer. */

array +=4; /* Modify the pointer. */

*array = 'x'; /* Modify the data pointed to

* by 'array' */

}

8.7. Returning values.Normally you would return an 'int', 'char', 'float', or 'double' using this technic. The obvious time to return a value

would be to return a completion code.

See example in section Definition above, where the contents of 'c' are copied into 'i'.

8.8. Returning pointers.Returning values is OK for the data types above but not very practical for 'char *' or structures. For these data types

passing pointers can be more appropriate. When using these pointers it is importand to understand the 'static' storage

class otherwise you are going to get some unpredictable results.

9. Operators and Expressions

Operators are used with operands to build expressions. For example the following is an expression containing twooperands and one oprator.4 + 5

The following list of operators is probably not complete but does highlight the common operators and a few of the

outrageous ones.C contains the following operator groups:

Arithmetic Assignment Logical/relational Bitwise Odds and ends!

9.1. Arithmetic+-

/*% modulo-- Decrement (post and pre)++ Increment (post and pre)


27/44


26

9.2. AssignmentThese all perform an arithmetic operation on the lvalue and assign the result to the lvalue. So what does this mean in

English? Here is an example:

can be reduced to

Here is the full set.=*= Multiply/= Divide.%= Modulus.+= add.-= Subtract.= Right shift.&= Bitwise AND.^= bitwise exclusive OR (XOR).|= bitwise inclusive OR.

9.3. Logical/Relational== Equal to!= Not equal to>= shift right~ one's complement

9.5. Odds and ends!sizeof() size of objects and data types.

strlen may also be of interest.& Address of (Unary operator)* pointer (Unary operator)? Conditional expressions: Conditional expressions, Series operator.

9.6. true or false.The concept of an expression evaluating to true or false is one of the corner stones of C. BUT the language derives

true and false in an unusual way. Basicly there is no boolean value. The number 0 is considered to be false and all

other numbers are considered to be true. Please consider the following expressions.(1 == 1) true(1 != 1) false(i = 1) true(i = 0) false(i = 1 + 1) true

The first two examples should be clear but the last ones need explanation .

The last three examples assign a value to a variable and a side effect of assignment is to return the value assigned,

it is this value that is tested to be true or false. Looking at the last example:

(i = 1 + 1)(i = 2)(2)

counter = counter + 1;

counter += 1;


28/44


27

The third expression assigns a value of 1 to i. 1 is considered to be true because it is non-zero.

The fourth expression assigns a value of 0 to i. 0 is considered to be false.

The fith expression assigns a value of 2 to i. 2 is considered to be true, because it is non-zero.

9.7. Confusion of == and = in IF statementsAn error which almost every C programmer has made is shown below:

main(){

int left=10;if ( left = 5 ){

puts(" Values are equal...");}

}

The program assigns 5 to the variable left and returns 5. This is interpreted as TRUE and causes theputs statement

to be executed everytime. Here is the corrected program.

main(){

int left=10;if ( left == 5 )/* Two equals is required. */

{puts(" Values are equal...");

}}

9.8. Idioms

Place \0 at the location pointed to by ptr then increment ptr*ptr++ = '\0';

Increment ptr then place \0 at the location pointed to by ptr

*++ptr = '\0';

This program will print itself! I guess it's not of any real use, but I think its clever.main(a) {a="main(a) {a=%c%s%c;printf(a,34,a,34);}"; printf(a,34,a,34);}

9.9. Operator PrecedenceThe following tables show the order in which operators

are evaluated. Please note the following.

The order in which the operands are evaluated is not

specified in the ANSII standard.

For readability you should not rely on these rules!

Put everything in brackets so you intension is clear

to the compiler and other programmers.

Summary precedencetable.All operators on the same line have the same

precedence. The first line has the highest precedence.

() [] -> .

! ~ ++ -- + - * & sizeof

* / %

+ -

>

< = >

== !=

&

^

|

&&

||

?:

= += -= *= /= %= &= ^= |= =

,

Here are some C idioms that may be useful.


29/44


1

Detailed precedence

tableAll operators in the same block have the same prece-

dence. The first block has the highest precedence.

Group Operator Description

Membership. () Function call.

[] Array.

-> Structure pointer.

. Structure member.

Unary. ! Logical NOT

~

++ Increment.

-- Decrement.

+

-

* Pointer to data

& Address of a variable.

sizeof

(type) type cast.

Binary * Multiply.

/ Divide.

% Modulo.

Binary + Addition

- Subtraction.

Bitwise > Shift Right.

Relational < Less than.

> Greater than.

= Greater than or equal to.

== Equal to.

!= Not equal to.

More Bitwise & bitwise AND

^ bitwise Excusive OR

| bitwise OR

Logical. && Logical AND

Logical. || Logical OR

Conditional ? : Conditional construct.

Assignment = Equals

+= assignment

-= assignment

*= assignment

/= assignment

%= assignment

&= assignment

^= assignment

|= assignment

= assignment

Series , Comma

10. Bitwise operations

Bitwise operators include:

& AND | OR ^ XOR > Shift Right ~ one,s complement

&= AND |= OR ^= XOR = Shift Right

10.1. AND OR and XORThese require two operands and will perform bit comparisions.

AND & will copy a bit to the result if it exists in both operands.main(){unsigned int a = 60; /* 60 = 0011 1100 */unsigned int b = 13; /* 13 = 0000 1101 */unsigned int c = 0;

c = a & b; /* 12 = 0000 1100 */}

OR | will copy a bit if it exists in eather operand.main()


30/44


30

{unsigned int a = 60; /* 60 = 0011 1100 */unsigned int b = 13; /* 13 = 0000 1101 */unsigned int c = 0;

c = a | b; /* 61 = 0011 1101 */}

XOR ^ copies the bit if it is set in one operand (but not both).main(){unsigned int a = 60; /* 60 = 0011 1100 */unsigned int b = 13; /* 13 = 0000 1101 */unsigned int c = 0;

c = a ^ b; /* 49 = 0011 0001 */}

10.2. One's ComplementThis operator is unary (requires one operand) and has the efect of 'flipping' bits.

main(){unsigned int Value=4; /* 4 = 0000 0100 */

Value = ~ Value; /* 251 = 1111 1011 */}

10.3. Bit shift.The following operators can be used for shifting bits left or right.

> =

The left operands value is moved (left or right) by the number of bits specified by the right operand. For example:

main(){unsigned int Value=4; /* 4 = 0000 0100 */unsigned int Shift=2;

Value = Value


31/44


31

0xff (Hexidecimal)0100 (Octal)'\xf' (Hex character)

Examples of their use are:int i=255; /* i assigned the decimal value of 255 */i-=0xff /* subtract 255 from i*/i+=010 /* Add Octal 10 (decimal 8) */

printf ("%i \n", '\xf'); /* Print 15 */Integer constants are assumed to have a datatype ofint, if it will not fit into an 'int' the compiler will assume the

constant is a long. You may also force the compiler to use 'long' by putting an 'L' on the end of the integer constant.1234L /* Long int constant (4 bytes) */

The other modifier is 'U' for Unsigned.1234U /* Unsigned int */

and to complete the picture you can specify 'UL'

1234UL /* Unsigned long int */

11.2. Floating point constants.Floating point constants contain a decimal point or exponent. By default they are double.

123.41e-2

11.3. Chararacter constants.Are actually integers.

'x''\000''\xhh'

See also ASCII Characters and Escape sequences

11.4. String constants.

Strings do not have a datatype of their own. They are actually a sequence of char items terminated with a \0. A stringcan be accessed with a char pointer. An example of a string would be:

char *Str = "String Constant";

See the discussion on strings for more information.

See also:#define - Strings

12. Arrays.

Arrays can be created from any of the C data types int, float, char. I start with int and float as these are the easiest to

understand. Then move onto int and float multi dimentional arrays and finally char arrays

int orfloat arrays.

two dimensional int orfloat arrays.

char arrays.

char multidimentional arrays.

12.1. int and float arraysTo define an integer or floating point variable you would say.

main(){int count; /* interger variable */float miles; /* floating point variable */

}


32/44


32

The syntax for an array is:

main(){int count[5]; /* interger 5 element array */float miles[10]; /* floating point 10 element array */

}

Now, the important fact is that the elements start at 0 (ZERO), so, 'count' above has elements 0, 1, 2, 3, 4.

To change the value of the 5th element we would code:main(){int count[5];count[4] = 20; /* index 4 is the 5th element */

}

If we want to initalise 'count' at definition we can say:

main(){int i;int count[5]={10, 20, 30};for (i=0; i< 5; i++){

printf("%d ", count[i]);

}

puts("")

}

The result will be:

10 20 30 0 0

We can see from the example above that the elements that have NOT been initalised have been set to zero.

One last thing to show you. If all the elements are being initialized when the variable is being declared, the compiler

can work out the number of elements for you. So this example will create an array with 3 elements.main(){int i;int count[]={10, 20, 30};

}

Don't forget all the stuff so far also applies to float.

12.2. Two dimensional int and float arrays.C does not actually support multi-dimensional arrays, but you can emulate them.

main(){int count[5];int matrix[10][4];

}

count has been seen before, it defines an array of 5 elements. matrix is defined as 10 arrays, all with 4 elements.

To initalise matrix at definition, you would code the following.

main()

{int thingy[4][2]={{1, 2},

{3, 4},{5, 6},{7, 8}};

}

Dont forget the last element will be thingy[3][1]

12.3. char arrays.char arrays work in the same way as int and float

main(){char letter;char letters[10];

}

'letter' can only hold one character but 'the 'letters' array could hold 10. It is important to think of 'char' as an array

and NOT a string. To initalise 'char' variables you can use the following syntax.


33/44


33

main(){char letter='x';char letters[10]='f','a','x',' ','m','o','d','e','m','\0';char text[10]="fax modem";

}

Note that the double quotes mean 'text string', so they will add theNULL automatically. This is the only time that

text can be loaded into an array in this way. If you want to change the contents of the array you should use the

function strcpy.

12.4. Two dimensional char arrays.Two dimensional char arrays are a different kettle of fish! We can follow the rules above to define the array as below

but it does not appear to be of much use!main(){char colours[][6]={"red","green","blue"};

}

Note we have specified 6 characters as a NULL will be added to the end of each string. The code above works, but

you dont seem to be able to access any of the strings! characters can be extracted as below:

main()

{char colours[][6]={"red","green","blue"};printf ("%c \n", colours[0][0]);

}

We don't have any pointers to the strings. To see how to get around this problem, read further about pointers.

13. Pointers.

Pointers are at the heart of C. When you crack this subject, you have got the worst of C behind you. Before you

tackle pointers though, you should get a grip on arrays.

First principles. Definition of a pointer.

Pointers to strings.

Pointers to arrays.

Char arrays verses char pointers.

Void pointers.

Pointers to pointers.

Pointers to functions.

Linked lists.

13.1. First Principles.To understand pointers, it may be worth understanding how normal variables are stored. What does the following

program realy mean?main(){int Length;

}

In my mind, it means, reserve enough storage to hold an integer and assign the variable name 'Length' to it. The data

held in this storage is undefined. Graphically it looks like:

To put a known value into 'Length' we code,

(Address) (Data)

F1


34/44


34

the decimal value 20 (Hex 14) is placed into the storage location.

Finally, the program is expanded to become:

main(){int Length;Length = 20;printf("Length is %d\n", Length);printf("Address of Length is %p\n", &Length);

}

The output would look something like this .....Length is 20

Address of Length is 0xF1

Please note the '&Length' on the second printf statement. The & means address ofLength. If you are happy with

this, you should push onto the pointers below.

13.2. Pointer definition.A pointer contains an address that points to data. An example of code defining a pointer is:

main(){int *Width;

}

A graphical representation could be...

So far, this variable looks the same as above, the value stored at 'Width' is unknown. To place a value in 'Width' you

could code.

main(){

int *Width;*Width = 34;}

(Address) (Data)

F1 0000 D1

F4 14 ------ 00 D2

00 D3

22 D4

Unlike the Length = 20 example above, the storage pointed to by 'Width' does NOT contain 34 (22 in Hex), itcontains the address where the value 34 can be found. The final program is...

main(){char *Width;

main(){int Length;Length = 20;

}

(Address) (Data)

F1


35/44


35

*Width = 34;

printf(" Data stored at *Width is %d\n", *Width);printf(" Address of Width is %p\n", &Width);printf("Address stored at Width is %p\n", Width);

}

The program would print out something like.

Data stored at *Width is 34Address of Width is 0xF1Address stored at Width is 0xD1

A pointer can point to any data type, ie int, float, char. When defining a pointer you place an * (asterisk) character

between the data type and the variable name, here are a few examples.main(){int count; /* an integer variable */int *pcount; /* a pointer to an integer variable */float miles; /* a floating point variable. */float *m; /* a pointer */char ans; /* character variable */char *charpointer; /* pointer to a character variable */

}

13.3. Pointers to arraysWhen looking at arrays we had a problem accessing the data within a two dimensional character array. This is what

the code looked like.

main(){char colours[][6]={"red","green","blue"};

}

The code above has defined 3 arrays, each containing 6 character strings. We can access the individual characters

with the following syntax.printf ("%c \n", colours[0][0]);

but can't extract a whole string. By using pointers as below, we can.main(){char *colours[]={"red","green","blue"};

}

This now defines an array of 3 pointers, all pointing to storage locations. So

printf("%s \n", colours[1]);

will return green.

13.4. Char Arrays versus Char pointersWhat is the difference between these to lumps of code?

main(){char colour[]="red";printf("%s \n",colour);

}

The answer is, not a great deal, at first sight! They both print the word red because in both cases 'printf' is being

passed a pointer to a string. The difference is on how the pointer is defined.

On the left, an array of 10 bytes is defined.

On the right a pointer to storage is defined.

In both cases 'colour' is a pointer.

On the left 'colour' is a pointer to 'colour[0]'.

On the right 'colour' is a pointer to a storage location.

The pointer can also point to dynamically allocated memory. See the malloc function for details.

main(){char *colour="red";printf("%s \n",colour);

}


36/44


36

13.5. Void PointersThere are times when you write a function but do not know the datatype of the returned value. When this is the case,

you can use a void pointer.

13.6. Pointers to functions

Example:/* Purpose: 1. Define a pointer to a function.

* 2. Point at a function.

* 3. Execute the function.*/

int (*fpointer)(void); /* Define a pointer to a function */

int func1(void); /* Define a few functions. */

int func2(void);

main()

{

fpointer = func1; /* Put the address of 'func1' in 'fpointer' */

fpointer(); /* Execute 'func1' */fpointer = func2; /* Repeat for 'func2' */

fpointer();

}

int func1(void)

{

puts("martin was ere");

}

int func2(void)

{

puts("alex was ere");

}

13.7. Linked ListsQuestion: How would you write a program to meet the following requirements?

1.Read an unknown number of records from a file into memory. A typical record would look like:Ref Title Cost

--- ----- ----1234 Oracle_Guide 22.95

2. Perform a numeric sort based on the first field.

3. Delete duplicate records based on the first field.

One method is to define an array of records as shown below:

main(){char array[50][80]; /* 50 records, 80 bytes long */

}

The data can first be read into the array and then actions performed on the data. This is in principle OK but has some

major problems.


37/44


37

1.The arrary will hold all the data in character format. It

would be nice to hold the integer and decimal numbers in

a more appropriate form.

2. If you have more than 50 records the program has to be

altered and recompiled.

The first problem could be fixed by defining an

array of structures BUT both problems can be solved with

linked lists.

The concept of a linked list is fairly simple. It is a group of

structures linked together by pointers, as shown in the figure

to the right.

The "Name Age Pointer" block could be defined as below:struct record {char name[20]; int age; struct record *next_rec;};

The important bit is "struct record *next_rec" this is the pointer to the next structure (record). It will either point to

the next record which will require memory reserved with the malloc function orNULL if its the last record.

See Also:VOID keyword. - function arguments - Strings - Arrays.

13.8. The malloc functionmalloc (memory allocation) is used to dynamically allocate memory at run time. Possible uses for this function are:

Read records of an unknown length.

Read an unknown number of database records.

Link lists.

The simplest way to reserve memory is to code something like:main(){char string[1000];

strcpy (string, "Some text");}

The example above has two problems:

If the data is less than 1000 bytes we are wasting memory.

If the data is greater than 1000 bytes the program is going to crash.

The 1000 bytes are reserved throught out the life of the program. If this was a long running program that rarely

used the memory ,it would again be waistfull.

malloc allows us to allocate exactly the correct amount of memory and with the use offree only for the time it is

required.

Example:

Looking at the example syntax above, 1000 bytes are reserved and the pointerString points to the first byte. The

1000 bytes are NOT initialized by malloc. If the memory is NOT available, aNULL pointer is returned. Please note,

the cast cast is required to return a pointer of the correct type.

C++ equivalentsnew is the C++ equivalent to malloc.

delete is the C++ equivalent to free.

14. Strings and Characters

Name Age Pointer

Name Age Pointer

NULL

Library: stdlib.hPrototype: void *malloc(size_t size);Syntax: char * String;

String = (char *) malloc(1000);


38/44


38

14.1. Pointers to strings.C does not have a "string" datatype. To create a string you have to use a char array or a charpointer. If you are not

familur with char arrays I recomend that you read about them now. To recap, a charpointer is defined like this:main(){char *Text;

}

All this program does is reserve storage that will hold an address. At this point the address could be anything. To

initalize Text you can code:main(){char *Text = "Thunder";

}

Text now has the address of the first character in Thunder. Graphically, things look like this.

Please note the 00 at the end ofThunder. This is theNULL character and is used to mark the end of a string.

If we wanted to O/P the data pointed to by a char pointer we can code.

Source:

Result:ThunderBird

This is all very well, but there is a MAJOR problem! Thunder and Bird are constants, they cannot be changed in

anyway. We need a method of pointing to some storage that can be altered and true to form, C provides a function

called malloc to do just that.

14.2. printf, sprintf, fprintf, scanf format identifiers.%d %i Decimal signed integer.%o Octal integer.%x %X Hex integer.%u Unsigned integer.%c Character.%s String. See below.%f double%e %E double.%g %G double.%p pointer.%n Number of characters written by this printf.No argument expected.%% %. No argument expected.

I. Except for %% and %n, all the identifiers expect to extract an argument from the printfparameter list.

II. All of the parmameters should be the value to be inserted. EXCEPT %s, this expects apointerto be passed.

(Address) (Data)

F1 0054 (T) D1

F4 D1 ------ 68 (h) D2

75 (u) D36E (n) D4

64 (d) D5

65 (e) D6

72 (r) D7

00 D8

main(){char *Text1 = "Thunder"; /* Define and initalize */char *Text2; /* Define only */

Text2 = "Bird"; /* Point to some text */

printf("%s%s\n", Text1, Text2);}


39/44


39

Example.main(){int number=5;char *pointer="little";printf("Here is a number %d and a %s word.\n", number, pointer);

}/*********************************

* Program result is: */Here is a number 5 and a little word.

Field width.By default the width of a field will be the minimum required to hold the data. In the example above the width of %s

becomes 6. If you want to control the field width you can use the following syntax.main(){int number=5;char *pointer="little";

printf("Here is a number-%4d-and a-%10s-word.\n", number, pointer);}

/********************************** Program result is: */

Here is a number- 5-and a- little-word.

As you can see, the data is right justified within the field. There is one other version of the field width that is used

with floating point numbers.%8.2f

This says you require a total field of 8 characters, within the 8 characters the last 2 will hold the decimal part.

FlagsThe format identifers can be altered from their default function by applying the following flags:

- Left justify.0 Field is padded with 0's instead of blanks.

+ Sign of number always O/P.blank Positive values begin with a blank.# Various uses:%#o (Octal) 0 prefix inserted.%#x (Hex) 0x prefix added to non-zero values.%#X (Hex) 0X prefix added to non-zero values.%#e Always show the decimal point.%#E Always show the decimal point.%#f Always show the decimal point.%#g Always show the decimal point, trailing zeros not removed.%#G Always show the decimal point, trailing zeros not removed.

I. The flags are placed between the % and the field width or format identifier.

II. Where it make sense, more than one flag can be used.

Here are a few more examples.printf(" %-10d \n", number);printf(" %010d \n", number);printf(" %-#10x \n", number);printf(" %#x \n", number);

14.3. Escape sequences.\n Newline\t Horizontal Tab\v Vertical Tab\b Backspace\r Carriage Return\f Form feed\a Audible Alert (bell)

\\ Backslash\? Question mark\' Single quote\" Double quote\000 Oct - No one uses Octal unless they have an ICL background...


40/44


40

\xhh Hex number\ Preprocessor line continuation, must be immediately followed by \n.

These can be used anywhere that C expects to see a character constant. Must be time for a quick example.main(){char word[]="\x6d\x6f\x64\x65\x6d";

printf("%s\n", word);

}Can you work out what will appear if you run this program??

14.4. Ascii character table in Hex.

00 01 02 03 04 05 06 0708 09 0A 0B 0C 0D 0E 0F10 11 12 13 14 15 16 1718 19 1A 1B 1C 1D 1E 1F20 21 ! 22 " 23 # 24 $ 25 % 26 & 27 '28 ( 29 ) 2A * 2B + 2C , 2D - 2E . 2F /

30 0 31 1 32 2 33 3 34 4 35 5 36 6 37 738 8 39 9 3A : 3B ; 3C C 3D = 3E > 3F ?40 @ 41 A 42 B 43 C 44 D 45 E 46 F 47 G48 H 49 I 4A J 4B K 4C L 4D M 4E N 4F O50 P 51 Q 52 R 53 S 54 T 55 U 56 V 57 W58 X 59 Y 5A Z 5B [ 5C \ 5D ] 5E ^ 5F _60 ` 61 a 62 b 63 c 64 d 65 e 66 f 67 g68 h 69 i 6A j 6B k 6C l 6D m 6E n 6F o70 p 71 q 72 r 73 s 74 t 75 u 76 v 77 w78 x 79 y 7A z 7B { 7C | 7D } 7E ~ 7F

15. Functions Summary

15.1. ANSI standard libraries.The ANSI library is declared in the following header files.

assert.h ctype.h errno.h float.h limits.h locale.h math.h setjmp.h signal.h stdarg.h stddef.h stdio.h

stdlib.h string.h time.h

15.2. ctype.hisalnum Checks whether a character is alphanumeric (A-Z, a-z, 0-9)

isalpha

iscntrl Checks whether a character is a control character or delete ( decimal 0-31 and 127)

isdigit Checks whether a character is a digit (0-9)

isgraph Checks whether a character is a printable character, excluding the space (decimal 32)

islower Checks whether a character is a lower case letter (a-z).

isprint Checks whether a character is printable (decimal 32-126).

ispunct Checks whether a character is punctuation (decimal 32-47, 58-63, 91-96, 123-126)

isspace Checks whether a character is white space - space, CR HT VT NL, FF.

isupper Checks whether a character is an upper case letter (A-Z).

isxdigit Checks whether a character is hex digit (0-9, A-F, a-f).

toupper Converts a lowercase character to uppercase. int toupper(int c)tolower Convert an uppercase character to lowercase. int tolower(int c)


41/44


41

15.3. math.hacos asin atan atan2 cos sin tan cosh sinh tanh exp frexp ldexp log log10 modf pow sqrt ceil fabs

floor fmod

Note! For some reason abs is in stdlib.h

15.4. stdio.hThis header defines all the ANSI I/O functions that allow you to read and write to files and devices. Low level (non

ANSI) functions are also available.

rename remove tmpfile tmpnam fflush freopen setbuf setvbuf fscanf vfprintf vprintf vsprintf scanf

ungetc fread fwrite fgetpos fseek fsetpos ftell rewind clearerr fseek

fclose Close a file.

fopen Open a file

fgetc Read a character from a file.

feofCheck for EOF while reading a file.

fgets Read a record from a file (safer than fgetc).

fprintfO/P a line of data to a file.fputc Put a charater into a file.

fputs Put a string into a file.

printfO/P data to the screen or a file.

sprintfO/P data in tha same way as 'printf' but put it into a string.

getc Get a character from an input stream.

getchar Get a character from the keyboard (STDIN).

gets Get string (from keyboard).

putchar O/P a character to STDOUT.

puts O/P data to the screen or a file.

sscanfExtract fields from a string.

15.5. stdlib.habort abs atexit atof atol calloc div exit labs ldiv mblen mbstowcs mbtowc realloc strtod strtoul

wctomb wcstombs

atoi Accepts +-0123456789 leading blanks and converts to integer.

bsearch Binary chop.

getenv Get an environmental variable.

free memory allocated with malloc.

malloc dynamically allocate memory.

qsort Sort an array.

rand Generate a random number.strtol String to long integer conversion. Takes data in various number bases.

srand Seed a random number.

system Issue a command to the operating system

15.6. string.hmemchr memcmp memcpy memmove memset strcoll strcspn strerror strlen strncat strncmp strpbrk

strspn strxfrm

strcpy Copy strings.

strcat Concatinate two strings.

strchr Search for a character in a string.

strcmp Compare strings.

strncpy Copy part of a string.

strrchr Search for a character in a string.


42/44


42

strstr Search a string for a substring.

strtokThe books say this function splits a string into tokens. I think its function is best described as parsing a string.

15.7. time.hasctime clock ctime difftime gmtime localtime mktime strftimetime

16. C Programming Examples

All the below examples and many more may be found on:

http://www.jaxnet.com/~garyg/C_ref/C/EXAMPLES/examples.html

They have been tested on a PC running Linux and using the 'gcc' compiler. You can extract the programs with the

'save' option under 'file' and compile with your own compiler.

Your first C program.

if.

while.

do.

for example 1. for A more advanced example.

switch.

function.

Global and local variables.

Increment & decrement.

Pass command line arguments.

Print from 10 to 1 - three examples.

Read a file - version 1.

manipulate strings.

Using 'curses' to read a password.

Programs requiring X. Unix users only.

Index of all example programs.

O'Reillys' Using C examples.

O'Reillys' Practical C examples.

Bob Stouts 'Snippets'.


43/44


43

17. Glossary of C Terms.

Address. Reference to a memory location. In Cpointers are used to hold addresses.

Argument. A value passed to a function (seeparameter).Block. A sequence ofdefinitions, declarations and statements, enclosed within braces {}.

Character Array. A set of elements of type char. (Can be used to store a string).

Class C++ term, not used in ANSI C.

Compilation error. Error which occurs during the translation of source code into machine code.

Compiler. A program which converts source code into machine code.

Compound Statement. A sequence of simple statements.

Constant An item that represents a value that cannot be changed. For Example:

(common all garden) 123'x'

Constant (symbolic) A symbol defined in a #define preprocessor directive to represent a constant value.

Data type. Definition of the data. int, char, float.

Declaration. A construct which associates attributes to a variable name or function.

No storage is reserved.

For example:

extrn int a;extrn char c;

variable declaration

A structure declaration could look like:

struct per_rec{int age;

char * surname;char * firstname;

};

Definition.

1. Variable definition is a declaration with storage allocation.

2. A construct which specifies the name,parameters and return type of a function.

For example a function definition would be:

Escape sequence. Control codes comprising combinations of a backslash followed by letters or digits which represent

non printing characters.

Executable program. Program which will run in the environment of the operating system or within an appropriate run time

environment.

Executable (stand-alone) Program which will run within the environment of the operating system without

program. additional utilities or support.

Expression. A sequence of operators and operands which may yield a single value.

File. Data stored as an electronic file.

File descriptor. This is used in low level I/O (open/read/write/close functions) to identify a file. It is an integernumber assigned to a file name by open and then used as a unique identifier by read/write and close.

Floating-point Number. Number having a decimal place or exponent.

Format specification. A string which controls how input or output shall be presented.

int a;char c;struct per_rec person;

long sqr(int num){return(num*num);}


44/44


Identifier. The names used to refer to stored data values such as constants, variables orfunctions.

Integer. A number without a fractional part.

Keyword. A word which has a predefined meaning to a 'C' compiler and therefore must not be used for any

other purpose.

library file. The file which contains compiled versions of commonly used functions which can be linked to an

object file to make an executable program.

Library function. A function whose code is contained in the external library file.

Line. One line of input from the standard input device (keyboard) which is terminated with a newline

character. The newline character is replaced by a null character.

Literal. Characters, letters orstrings which are to be taken literally and used as constants rather than

identifiers.

Object C++ term, not used in ANSI C.

Object Code. Code which is directly understandable by the machine (machine code).

Operand. An expression acted on by an operator. For example:

z = a + b;

a and b are both operands of the + operator.

Parameter. A value received by afunction.

Pointer. Variable containing an address.

Polymorphism C++ term, not used in ANSI C.

Precedence (of operators) The order in which operators are dealt with during the evaluation of an expression.

Preprocessor. A processor which manipulates the initial directives of the source file which contains instructions

about how the source file shall be processed and compiled.

Preprocessor directive. Source file instruction about how the file shall be processed and compiled.

Program. A text file comprising code which can be compiled.

Run time error. An error which occurs when a program is executed.

Reserved word Same as keyword. A word which has a predefined meaning to a 'C' compiler and therefore must notbe used for any other purpose.

Scope.

Source code. A text file comprising code which can be compiled.

Statement. A simple statement is an expression followed by a semicolon. (See compound statement andblock).

String. A string in 'C' is an array of characters terminated by aNull character ('\0').

Syntax error. A mistake in the source code which prevents the compiler from converting it into object code.

Variable. An identifier (and storage) for a data type and for which the data value is allowed to change as the

program runs.

Date post:	06-Apr-2018
Category:	Documents
Upload:	anu-gs
View:	246 times
Download:	0 times

ANSI C Programming Reference

Documents