operators&variable5-9-11.ppt

(1)

1

Tokens in C



Keywords

_{These are reserved words of the C language. For example}_int, float, if, else, for, while etc.



Identifiers

 _{An Identifier is a sequence of letters and digits, but must start with a}

letter. Underscore ( _ ) is treated as a letter. Identifiers are case sensitive. Identifiers are used to name variables, functions etc.

 _Valid:_{Root, _getchar, __sin, x1, x2, x3, x_1, If}  _Invalid:_{324, short, price$, My Name}



Constants

(2)

2

Tokens in C



String Literals

 _{A sequence of characters enclosed in double quotes as “…”. For}

example “13” is a string literal and not number 13. ‘a’ and “a” are different.



Operators

 _{Arithmetic operators like}_{+, -, *, / ,%}_etc.  _{Logical operators like}_{||, &&, !}_{etc. and so on.}



White Spaces

 _{Spaces, new lines, tabs, comments ( A sequence of characters enclosed}

(3)

String Literals



A sequence of any number of characters

surrounded by double quotation marks.



Example:



“Human Revolution”



How to write special double quotation mark?



“”” is ambiguous, so use escape character



Example: printf(“He shouted, \“Run!\””);

output: He shouted, “Run!”

(4)

String Literals

Escape

Sequence

Name

Meaning

\a

Alert

Sounds a beep

\b

Backspace

Backs up 1 character

\f

Formfeed

Starts a new screen of page

\n

New line

Moves to beginning of next line

\r

Carriage return

Moves to beginning of current line

\t

Horizontal tab

Moves to next tab position

\v

Vertical tab

Moves down a fixed amount

\\

Back slash

Prints a back slash

(5)

5

Basic Data Types



Integral Types

 _{Integers are stored in various sizes. They can be signed or unsigned.}  _Example

Suppose an integer is represented by a byte (8 bits). Leftmost bit is sign bit. If the sign bit is 0, the number is treated as positive.

Bit pattern 01001011 = 75 (decimal).

The largest positive number is 01111111 = 27 _{– 1 = 127.}

Negative numbers are stored as two’s complement or as one’s complement.

(6)

6

Basic Data Types



Integral Types

 _char _{Stored as 8 bits. Unsigned 0 to 255.}

Signed -128 to 127.

 _{short int} _{Stored as 16 bits. Unsigned 0 to 65535.}

Signed -32768 to 32767.

 _int _{Same as either short or long int.}

 _{long int} _{Stored as 32 bits. Unsigned 0 to 4294967295.}

(7)

7

Basic Data Types



Floating Point Numbers

 _{Floating point numbers are rational numbers. Always signed numbers.}  _float _{Approximate precision of 6 decimal digits .}

• Typically stored in 4 bytes with 24 bits of signed mantissa and 8 bits of signed exponent.

 _double _{Approximate precision of 14 decimal digits.}

• Typically stored in 8 bytes with 56 bits of signed mantissa and 8 bits of signed exponent.

 _{One should check the file limits.h to what is implemented on a particular}

(8)

8

Constants



Entities that appear in the program code as fixed values.



4 types of constants:



Integer constants



Floating-point constants



Character constants

(9)

Integer Constant

Positive or negative whole numbers with no fractional part

Optional + or – sign before the digit.

It can be decimal (base 10), octal (base 8) or hexadecimal

(base 16)

Hexadecimal is very useful when dealing with binary numbers

Example:

const int MAX_NUM = 10;

const int MIN_NUM = -90;

(10)

Integer Constant

Rules for Decimal Integer Constants

1. Decimal integer constants must begin with a nonzero

decimal digit, the only exception being 0, and can contain

decimal digital values of 0 through 9. An integer that begins

with 0 is considered an octal constant

2. If the sign is missing in an integer constant, the computer

assumes a positive value.

3. Commas are not allowed in integer constants. Therefore,

1,500 is illegal; it should be 1500.

Example of legal integer constants are –15, 0, +250 and 7550

0179 is illegal since the first digit is zero

(11)

Floating Point Constant

Positive or negative decimal numbers with an

integer

part(optional), a

decimal point

, and a

fractional

part

(optional)

Example 2.0, 2., 0.2, .2, 0., 0.0, .0

It can be written in conventional or scientific way

20.35 is equivalent to 0.2035E+2 (0.2035 x 10

2

)

0.0023 is equivalent to 0.23e-2 (0.23 x 10

-2

)

E or e stand for “exponent”

(12)

Floating Point Constant

C support 3 type of Floating-point: float (4 bytes), double (8

bytes), long double (16 bytes)

By default, a constant is assumed of type double

Suffix f(F) or l(L) is used to specify float and long double

respectively

Example:

const float balance = 0.125f;

const float interest = 6.8e-2F

const long double PI = 3.1412L;

(13)

13

Constants



Character and string constants

_‘c’_{, a single character in single quotes are stored as char.}

Some special character are represented as two characters in single quotes.

‘\n’ = newline, _‘\t’= tab, _‘\\’ = backlash, _‘\”’ = double quotes. Char constants also can be written in terms of their ASCII code.

‘\060’ = ‘0’ (Decimal code is 48). How to write a single quotation mark?

‘’’ is ambiguous, so escape character – back slash \ ‘\’’

 _{A sequence of characters enclosed in double quotes is called a string}

constant or string literal. For example

“Charu” “A”

(14)

String Literals



A sequence of any number of characters

surrounded by double quotation marks.



Example:



“Human Revolution”



How to write special double quotation mark?



“”” is ambiguous, so use escape character



Example: printf(“He shouted, /“Run!/””);

output: He shouted, “Run!”

(15)

Characters and tokens



Characters are the basic building blocks in C

program, equivalent to ‘letters’ in English

language



Includes every printable character on the

standard English language keyboard except `, $

and @



Example of characters:



Numeric digits: 0 - 9



Lowercase/uppercase letters: a - z and A - Z



Space (blank)

(16)



A token is a language element that can be used

in forming higher level language constructs



Equivalent to a ‘word’ in English language



Several types of tokens can be used to build a

higher level C language construct such as

expressions and statements



There are 6 kinds of tokens in C:



Reserved words (keywords)



Identifiers

(17)

17

Global and Local Variables



Global Variables

_{These variables are}

declared outside all functions.

 _{Life time of a global}

variable is the entire execution period of the program.

 _{Can be accessed by any}

function defined below the declaration, in a file.

/* Compute Area and Perimeter of a circle */

#include <stdio.h>

float pi = 3.14159; /* Global */

main() {

float rad; /* Local */

printf( “Enter the radius “ ); scanf(“%f” , &rad);

if ( rad > 0.0 ) {

float area = pi * rad * rad; float peri = 2 * pi * rad;

printf( “Area = %f\n” , area ); printf( “Peri = %f\n” , peri ); }

else

printf( “Negative radius\n”);

printf( “Area = %f\n” , area ); }

float pi = 3.14159; /* Global */

main() {

float rad; /* Local */

printf( “Enter the radius “ ); scanf(“%f” , &rad);

if ( rad > 0.0 ) {

else

(18)

18

Global and Local Variables



Local Variables

 _{These variables are}

declared inside some functions.

 _{Life time of a local}

variable is the entire execution period of the function in which it is defined.

 _{Cannot be accessed by any}

other function.

 _{In general variables}

declared inside a block are accessible only in that block.

float pi = 3.14159; /* Global */

main() {

float rad; /* Local */

if ( rad > 0.0 ) {

else

printf( “Area = %f\n” , area ); }

float pi = 3.14159; /* Global */

main() {

float rad; /* Local */

if ( rad > 0.0 ) {

printf( “Area = %f\n” , area ); printf( “Peri = %f\n” , peri ); }

else

(19)

19

Operators



Arithmetic Operators

_{+, - , *, /}_{and the modulus operator %.}

 _{+ and – have the same precedence and associate left to right.}

3 – 5 + 7 = ( 3 – 5 ) + 7  3 – ( 5 + 7 ) 3 + 7 – 5 + 2 = ( ( 3 + 7 ) – 5 ) + 2

 _{*, /, %}_{have the same precedence and associate left to right.}  _The_{+, -}_{group has lower precendence than the}_{*, / %}_group.

3 – 5 * 7 / 8 + 6 / 2 3 – 35 / 8 + 6 / 2 3 – 4.375 + 6 / 2 3 – 4.375 + 3

-1.375 + 3

(20)

20

Operators



Arithmetic Operators

 _{% is a modulus operator. x % y results in the remainder when x is divided}

by y and is zero when x is divisible by y.

 _{Cannot be applied to float or double variables.}  _Example

if ( num % 2 == 0 )

printf(“%d is an even number\n”, num)’; else

(21)

21

Type Conversions

 _{The operands of a binary operator must have a the same type and the}

result is also of the same type.

 _{Integer division:}

c = (9 / 5)*(f - 32)

The operands of the division are both int and hence the result also would be int. For correct results, one may write

c = (9.0 / 5.0)*(f - 32)

 _{In case the two operands of a binary operator are different, but}

compatible, then they are converted to the same type by the compiler. The mechanism (set of rules) is called Automatic Type Casting.

c = (9.0 / 5)*(f - 32)

 _{It is possible to force a conversion of an operand. This is called}_Explicit

Type casting.

(22)

22

Automatic Type Casting

1. char and short operands are converted to int

2. Lower data types are converted to the higher data types and result is of higher type.

3. The conversions between unsigned and signed types may not yield intuitive results.

4. Example

float f; double d; long l; int i; short s;

d + f f will be converted to _double

i / s s will be converted to _int

l / i i is converted to _long; _long result

Hierarchy

Double float long Int

(23)

23

Explicit Type Casting

 _{The general form of a type casting operator is}  _{(type-name) expression}

 _{It is generally a good practice to use explicit casts than to rely on}

automatic type conversions.

 _Example

C = (float)9 / 5 * ( f – 32 )

 _float_to_int_{conversion causes truncation of fractional part}  _double_to_float_{conversion causes rounding of digits}

(24)

24

Precedence and Order of evaluation

(25)

Lectures on Numerical Methods 25

Precedence and Order of evaluation

(26)

26

Operators



Relational Operators

 _{<, <=, > >=, ==, != are the relational operators. The expression} operand1 relational-operator operand2

takes a value of 1(int) if the relationship is true and 0(int) if relationship is false.

 _Example

int a = 25, b = 30, c, d; c = a < b;

d = a > b;

(27)

27

Operators



Logical Operators

 _{&&, ||}_and_!_{are the three logical operators.}

 _{expr1 && expr2}_{has a value 1 if}_expr1_and_expr2_{both are nonzero.}  _{expr1 || expr2}_{has a value 1 if}_expr1_and_expr2_{both are nonzero.}  _!expr1_{has a value 1 if expr1 is zero else 0.}

 _Example

(28)

28

Operators



Assignment operators

 _{The general form of an assignment operator is}  _{v op= exp}

 _{Where v is a variable and op is a binary arithmetic operator. This}

statement is equivalent to

 _{v = v op (exp)}

(29)

29

Operators



Increment and Decrement Operators

 _{The operators}₊₊_and_–-_{are called increment and decrement operators.}  _a++_and_++a_{are equivalent to}_{a += 1}_.

 _a--_and_--a_{are equivalent to}_{a -= 1}_.

 _{++a op b}_{is equivalent to}_{a ++; a op b;}  _{a++ op b}_{is equivalent to}_{a op b; a++;}  _Example

(30)

30

Floating Point Arithmetic



Representation

 _{All floating point numbers are stored as}

 such that d₁ is nonzero. B is the base. p is the precision or number of

significant digits. e is the exponent. All these put together have finite number of bits (usually 32 or 64 bits ) of storage.

 _Example

 _{Assume B = 10 and p = 3.}  _{23.7 = +0.237E2}  _{23.74 = +0.237E2}  _{37000 = +0.370E5}  _{37028 = +0.370E5}

 _-0.000124 _{= -0.124E-4}

e p

B

d

