chapter 7 simple data types and function calls alkar / demirer

Chapter 7Simple Data Types and

Function Calls

Alkar / Demirer

Copyright ©2004 Pearson Addison-Wesley. All rights reserved. 7-2

Representation and Conversion of Numeric Types• Simple data typeSimple data type is the data type used to store a

single value.– e.g., int, double, and char.

• Operations involving integer are faster than those involving double.

• Operations with integer are always precise, whereas loss of accuracy may occur when dealing with double.


Internal Formats of Type int and Type double• IntegersIntegers are represented by standard binary

numbers.– e.g., 7 = 01101.

• DoublesDoubles are represented by two sections: mantissamantissa and exponentexponent.– real number = mantissa * 2exponont

– 4.0 = 0010 * 20001 = 2 * 21


Integer Types in C

Type Range

short -32767 .. 32767

unsigned short 0 .. 65535

int -32767 .. 32767

unsgined 0 .. 65535

long -2147483647 .. 2147483647

unsgined long 0 .. 4294967295


Floating-Point Types in C

Type Range

float 10-37 .. 1038

double 10-307 .. 10308

long double 10-4931 .. 104932


An Example to Print Ranges for Positive Numeric DataYou can determine the maximal or minimal int and double values of your C environment by the following program.

%e is the format in scientific notation


Numerical Inaccuracies

• The representation errorrepresentation error (or round-off round-off errorerror) is an error due to coding a real number by a finite number of digits.– e.g., the faction of 1/3 is 0.3333…

– It is impossible to code the precise value of 1/3.

• The representation error depends on the number of digits used in the mantissamantissa.– The more bits, the smaller the error.


An Example of the Representation Error• for (trial = 0.0;

trial != 10.0; trial = trial + 1) {

…}

• The result of adding 0.1 for one hundred times is not exactly 10.0.– The above loop may fail to terminatefail to terminate on some

computers.


Other Problems When Manipulating Numbers• Cancellation errorCancellation error is an error resulting from

applying an operation to a large number and a small number, and the effect of the smaller number is lost.– e.g., 1000.0 + 0.0000001234 is equal to 1000.0.

• Arithmetic underflowArithmetic underflow is an error in which a very small computational result is represented as zero.– e.g., 0.00000001 * 10-1000000 is equal to 0.


Other Problems When Manipulating Numbers• Arithmetic overflowArithmetic overflow is an error in which the

result is too large to be represented.– The error may be detected in compiling time or run

time.– Some machine may let the arithmetic overflow occur

and the computational result is unexpected.– e.g., 999999999 * 109999999 may become a negative

value in some machine.


Automatic Conversion of Data Types (1/2)• The data of one numeric type may be automatically

converted to another numeric type.

e.g.,int k = 5, m = 4, n;double x = 1.5, y = 2.1, z;

Context Example Explanation

Expression with binary operator and operands of different types

k + xvalue is 6.5.

Value of k is converted to double before the operation.


Automatic Conversion of Data Types (2/2)

Context Example Explanation

Assignment with type double target variable and type int expression

z = k / m;expression value is 1.25; z is 1.0.

Expression is evaluated first. Then the result is converted to double.

Assignment with type int target variable and type double expression

n = x * y;expression value is 3.15; n is 3.

Expression is evaluated first. Then the result is converted to int.


Explicit Conversion of Data Types

• C also provides an explicit type conversion operation called castcast.

• For example, frac = n1 / d1;if n1 = 2 and d1 = 4, frac would be 0.

• CastCast: place the name of the desired type in parentheses immediately before the value to be converted.– e.g., frac = (double)n1 / (double)d1;– frac is evaluated to 0.5.


Representation and Conversion of Type char (1/2)• Character values can be compared by the

equality operatorsequality operators == and !=, or by the relational operatorsrelational operators <, <=, >, and >=.

e.g., letter = ‘A’; if (letter < ‘Z’) …

• Character values may also be compared, scanned, printed, and converted to type int.


Representation and Conversion of Type char (2/2)• Each character has its own unique numeric code.• A widely used standard is called American American

Standard Code for Information Interchange Standard Code for Information Interchange (ASCII)(ASCII). (See Appendix A in the textbook)– The printable charactersprintable characters have codes from 32 to

126, and others are the control characterscontrol characters.– For example, the digit characters from ‘0’ to ‘9’ have

code values from 48 to 57 in ASCII.

• The comparison of characters (e.g., ‘a’<‘c’) depends on the the corresponding code values in ASCII.


An Example of the Conversion between char and intC permits conversion of type char to type int and vice versa.

Convert char to int

Convert int to char


Enumerated Types (1/2)

• Enumerated typeEnumerated type is a data type whose list of values is specified by the programmer.

• Syntax: typedef enum {identifier_list} enum_type;

• e.g., typedef enum{entertainment, rent, food, clothing}expense_t;


Enumerated Types (2/2)• In the above example, a new data type expense_t is

created, and we can declare a variable with this type:

e.g., expense_t expense_kind;

• The variable expense_kind can be manipulated as any other integer.

e.g., switch(expense_kind){ case entertainment:

printf(“entertainment”);break;

case rent: case food: …


Functions: Arguments are passed by values• Argument lists are used to communicate information from the

main function to its function subprograms. – Arguments make functions more versatile because they allow us

to execute the same function with different sets of data.• Return values are used to communicate information from the

function subprogram back to the main program.• We can use output parameters to return multiple results from

a function.• When a function is called, it is given a copy of the values that

are passed in as arguments.– If you manipulate the value of an argument, it has no impact on

its value in the main function– Therefore, these are called input parameters, because they can

only bring information into the function, and not back out.


Function Parameters (1/2)

• When invoking a function call, we can include function function parametersparameters in the parameter list.

• Declaring a function parameterfunction parameter is accomplished by simply including the prototype of the functionprototype of the function in the parameter list.

A function parameter


Function Parameters (2/2)

• Suppose there are two existed functions: double sqrt(double)double sqrt(double) , and double sin(double)double sin(double).

• evaluateevaluate is a function that includes a function parameter as shown in the previous slide.

• We can invoke evaluateevaluate as follows.evaluateevaluate(sqrtsqrt, 0.25, 25.0, 100.0);evaluateevaluate(sinsin, 0.0, 3.14159, 0.5*3.14159);


Example with pass by valuevoid myFunc(int arg);

int main(void){ int x = 5; myFunc(x); printf(“%d\n”, x);}

void myFunc(int arg){ arg = 4;}

/* Output */

5


In main: int x = 5;

In main, x is assigned the value 5.This places the value 5 in the memory cell reserved for x

In this case, it is at address 0x234


In main: myFunc(x);

We call the function myFunc and pass it the value of xmyFunc allocates a new memory cell for its formal parameter argThe value 5 (a copy of the value in x) is placed in arg


In myFunc: arg = 4;

In myFunc, arg is assigned the value of 4This places the value 4 in the memory cell for argThis is not the same cell as x


In main: printf(“%d\n”, x);

Back in main, when we print out x, the value it points to is still 5.


Functions: Arguments are passed by Reference

• What if we want our changes to the value in the function to affect the value in the main function?

• We can accomplish that by passing the address of a variable as argument to a function and manipulate that variable inside the function.

• In the formal parameter list, we put a * in front of the parameter name.– This defines a pointer, which means that we will be passing the address

of the value, rather than the value itself.• In the function call, we put an & in front of the argument name.

– The & tells the compiler to pass the address of the variable, not its value.

• When we need to access the value of the argument in the function, we put a * in front of the variable name– This * tells the compiler to access the value pointed to by the address in

the variable.


Example with pass by referencevoid myFunc(int* arg);

int main(void){ int x = 5; myFunc(&x); printf(“%d\n”, x);}

void myFunc(int* arg){ *arg = 4;}

/* Output */

4


In main: int x = 5;

In main, x is assigned the value 5, just like before.The address of the memory cell for x is 0x234

The value of &x is 0x234


In main: myFunc(&x);

When we call myFunc, we pass it &x, the address of xThis value is stored in the memory cell for arg.arg == 0x234, *arg == 5


In myFunc: *arg = 4;

When we set the value of *arg, we are setting the value pointed to by arg – the value at 0x234


In main: printf(“%d\n”, x);

Back in main, the value of x is now 4


#include <stdio.h>#include <math.h>

void separate(double num, char *signp, int *wholep,double *fracp);

int main(void){ double value, fr; char sn; int whl;

printf("Enter a value to analyze> "); scanf("%lf", &value);

separate(value, &sn, &whl, &fr); printf("Parts of %.4f\n sign: %c\n", value, sn); printf(" whole number magnitude: %d\n", whl); printf(" fractional part: %.4f\n", fr); return 0;}


void separate(double num, char *signp, int *wholep,double *fracp){ double magnitude; if (num < 0) *signp = ’-’; else if (num == 0) *signp = ’ ’; else *signp = ’+’;

magnitude = fabs(num); *wholep = floor(magnitude); *fracp = magnitude - *wholep;}Parts of 35.8170sign: +whole number magnitude: 35fractional part: 0.8170


Figure 6.4 Parameter Correspondence for separate(value, &sn, &whl, &fr);


Common Errors with Pointers

• Note that this is a run-time error. It will not cause a compiler error.

• Therefore, make sure you set a pointer equal to the address of some variable (of the correct type!) before you attempt to use it.

• For example:

double x = 10.0, y = 20.0, *p_x, *p_y;p_x = &x;

printf(“x = %f and y = %f\n”, *p_x, *p_y);

ERROR!This will cause the program

to crash as p_y has not been initialized.


The Conditional Expression Operator

• Condition ? expression 1: expression 2

• Max_value = (a>b) ? a : b;

• S = (x <0) ? -1 : x*x


Scope of Names

• The scope of a name refers to the region of a program where a particular meaning of a name is visible or can be referenced.

• #define variables scope begins at their definition and ends at the end of the source file. All functions can “see” these variables.

• The scope of the name of a function begins with the function prototype and ends with the end of the source file.

• All formal parameter names and local variables are visible only from their declarations to the closing brace of the function in which they are declared.

chapter 7 simple data types and function calls alkar / demirer

Documents