1. Instructor: Sanchita Mal-Sarkar Course: CIS 265
Data Structures
Instructor: Sanchita Mal-Sarkar
Course: CIS 265

2. Data representation
Computer represents “on” with a 1 and “off” with a 0. These numbers are called binary digits or bits.
Binary number system: most widely used method for interpreting bit settings as nonnegative integers.
38 (decimal) = =

3. Ones complement notation
One of the widely used methods for representing negative binary numbers.
A negative number is represented by changing each bit to the opposite bit setting.
Example:
38 (decimal) = (binary)
-38 (decimal) = (binary)

4. Twos complement notation
Another popular method of representing negative binary number
In this method, 1 is added to the ones complement representation of a negative number.
Example:
-38 (decimal) = (ones complement)
-38 (decimal) = (twos complement)

5. Floating-point notation
Usual method to represent real numbers
Real number is represented by a number, called a mantissa, times a base raised to an integer power, called an exponent.
Example:
= x 10 -2
Other possibilities x 10 3, x100
(we choose mantissa is an integer with no tailing 0s)

6. Floating-point notation(cont.)
A real number is represented by a 32-bit string.
24-bit for mantissa and 8-bit for exponent.
Base is fixed to 10.
Example
100 = = =
( 24-bit binary representation of is
8-bit twos complement binary representation of -2 is )

7. Modular Programming & Pointers
Modules in C are called functions.
Each module or smaller piece is more manageable than the original program.
This technique is called divide and conquer.
Arguments make functions more versatile because it enable a function to manipulate different data each time it is called.
You know, how to pass input parameters into a function.
I will discuss how to use output parameters to return multiple results from a function.
Pointer to a variable provides the address to that type of variable.

8. Example #include <stdio.h> #include <math.h>
void determine_sign(double num, char *signp);
int main(void) {
double value;
char sn;
printf(“Enter a value>”);
scanf(“%lf”, &value);
determine_sign( value, &sn);
printf(“The sign of %.4f is: %c\n”, value, sn);
return (0); }

9. Example void determine_sign(double num, char *signp) { if (num < 0)
else if (num == 0)
*sign = ‘ ‘;
else
*sign = ‘+’; }

10. Pointers
A pointer is a variable that contains memory address as its value.
A variable directly contains a specific value.
A pointer contains an address of a variable that contains a specific value.
We use pointers extensively to create and manipulate dynamic data structures ( linked lists, queues, stacks, and trees), and to simulate call by reference.

11. Pointer
Pointers should be initialized either when they are declared or in an assignment statement.
Pointer can be initialized to 0, NULL, or an address.
A pointer with the value NULL points to nothing.
Initializing a pointer to 0 is equivalent to initializing to NULL (NULL is preferred);
NULL is a symbolic constant defined in <stdio.h> header file.

12. Representation of a Pointer
int x = 84; // declaration
int *ptr; // declaration
ptr = &x;
X directly references a
variable whose value is 84 84
Assigned the address of
the variable x to pointer
variable ptr. Direct value
of ptr is the address of x. x 84
ptr x
ptr indirectly references a
variable whose value is 84

13. Representation of x and ptr in memory
int x = 84; // declaration
int *ptr; // declaration
ptr = &x; // assigned the address of the // variable x to pointer variable ptr.
60000
ptr
Ptr indirectly references a
variable whose value is 84
50000 84 x
X directly references a
variable whose value is 84
60000

14. Different ways to pass arguments to a function
Two ways to invoke functions:
Call by value
Call by reference
Call by value:
When arguments are passed call by value,
a copy of the argument’s value is made and passed to the called function.
Changes to the copy do not affect an original variable’s value in the caller.

15. Call by Reference When an argument is passed by reference,
the caller actually allows the called function to modify the original variable’s value.
It is possible to simulate call by reference by using address operators and indirection operators.

16. Cube a variable using call by value
#include <stdio.h>
int cubeByValue(int);
main() {
int number = 5, number1;
printf(“The original value of number is %d\n”, number);
number1 = cubeByvalue(number));
printf(“The new value of number is %d\n”, number1);
return 0; }
int cubeByValue(int n)
return n * n * n;

17. Cube a variable using call by Reference
#include <stdio.h>
void cubeByReference(int *);
int main() {
int number = 5;
printf(“The original value of number is %d\n”, number);
cubeByReferencee(&number));
printf(“The new value of number is %d\n”, number);
return 0; }
void cubeBy Reference(int *nPtr)
*nPtr = *nPtr ** nPtr * *nPtr;

18. Pointer Arithmetic
A limited set of arithmetic operators may be performed on pointers.
A pointer may be incremented (++) or decremented (--).
An integer may be added to a pointer (+ or +=).
An integer may be subtracted from a pointer
(+ or +=).
One pointer may be subtracted from another.

19. Example int a[10]= {1,2,3,4,5}; int *ptr; ptr = a;
When an integer is added to or subtracted from a pointer, the pointer is not simply incremented or decremented by that integer.
It depends on the size of the object a pointer point to => machine dependent. 1 5 4 3 2
a + 1
a + 3
ptr a

20. Example (Increment)
When an integer is added to a pointer, the pointer is incremented by that integer times the size of the object to which the pointer points to.
int *ptr;
ptr = a;
ptr += 2;
will produce:
3008 ( * 4)
integer is stored in 4 bytes of memory. 1 5 4 3 2
a + 1
a + 3
ptr a
3000
3004
3008
3012
3016

21. Example (Decrement)
When an integer is subtracted from a pointer, decremented by that integer times the size of the object to which the pointer points to.
int *ptr;
ptr = a;
ptr += 2;
ptr -= 1;
will produce:
3004 ( * 4)
integer is stored in 4 bytes of memory.
3016
3000
3008
3004
3012 1 2 3 4 5 a
ptr
a + 3
a + 1

22. Subtraction Pointer variables may be subtracted from one another.
ptr1 contains the location 3000.
ptr2 contains the location 3008.
x = ptr2 - ptr1;
= 2
will assign to x
the number of
array elements
from ptr1 to ptr2 1 5 4 3 2
ptr2
ptr1 a
3000
3004
3008
3012
3016

23. Relationship between Pointers and Arrays
Arrays and Pointers are intimately related in C.
Array subscripting notation is converted to pointer notation during compilation.
Array name is a pointer to the first element of the array.
ptr = &a[0]
*(ptr + 3)  a[3]
&a[3]  (ptr + 3)
a += 2 invalid => attempts to modify the value of array name with pointer arithmetic. 1 5 4 3 2
a[1]
a[3]
ptr a
Offset to the pointer

24. Array of Pointers Array may contain pointers (e.g. string array).
In C, string is essentially a pointer to its first character.
Each entry in an array of strings is actually a pointer to the first character of a string.
Example:
char *names[4] = {“John”, “Cynthia”, “David”, “Daniel”};
names[4] => an array of 4 elements.
Char * => each element of array names is of type “pointer to char.”
Four array elements are: “John”, “Cynthia”, “David”, “Ruben”.
Each of these are stored in memory as a NULL-terminated character string that is one character longer than the number of characters between quotes.
E.g. Four strings are 5, 8, 6, and 7.

25. Example of array of pointers
It seems that the strings are placed in the names array,
Actually, only the pointers are stored in the array.
Each pointer points to the first character of its corresponding string.
Names is a fixed size array.
However it provides access to character strings of any length.
Names could have been placed into a double array of fixed number of columns per row => memory could be wasted.
‘J’
‘\0’
‘D’
‘h’
‘C’
‘n’
‘y’
‘o’
‘a’
‘i’
‘v’
‘t’
‘l’
‘d’
‘e’
names[0]
names[1]
names[2]
names[3]

26. Pointer to Functions
Pointer to a function contains the address of the function in memory.
A function name is really the starting address in memory of code that performs the function’s task.
Pointers to functions can be passed to functions, returned from functions, stored in arrays, and assigned to another function pointers.
int (*compare)(int num[1], int num[4])
Parenthesis s are needed around *compare
because * has lower precedence than parentheses
enclosing the function parameters.

27. Representation and conversion of Numeric Types
Why we need more than one numeric type ?
We could use data type double for all numbers. However, they are represented in the computer’s memory in different ways. Here are some advantages of integer data type:
On many computers, operation will be faster if we use integer instead of type double.
We need less space to store integer number .
Operations with integer are always precise. But in operations with double numbers can result in some loss of accuracy or round-off error.

28. Advantages of Type double Format
A real number has an integral part and a fractional part. But an integer number can not have a fractional part. So real number can not be represented by an integer, it can be represented by double data type.
Another advantage of the data type double is that much larger range of numbers can be represented as compared to type int.
Actual ranges vary from one implementation to another.
ANSI standard for C
min range of positive values of type int: , 767
min range of positive values of type double: to 10 37

29. Internal formats of Type int & Type double
All data are represented in memory as binary strings (strings of 0s and 1s).
However, the binary string stored for type int value 24 is not the same as the binary string stored for the type double number 24.0.
The actual internal representation is computer dependent.
Positive integers are represented by standard binary numbers. Integer 24 is represented by binary number
The format of type double is analogous to scientific notation.
binary number
type int format
mantissa
exponent
type double format

30. Scientific Notation
A real number has an integral part and a fractional part which are separated by a decimal point.
Very large or very small values can be represented by scientific notation.
Example: for the value => scientific notation: 1.23
In C scientific notation: 1.23e5 or 1.23E5
Read the letter e or E as "times 10 to the power".
If the exponent has a minus sign, the decimal point is moved to the left.
Example: 0.34e-4 ==

31. Numerical Inaccuracies
Sometimes an error occurs in representing real numbers.
Analogy: in decimal system, 1/3 is …..
Some fractions canot be represented exactly as binary numbers in the mantissa of the type double format.
This inaccuracy is called representational error.
It depends on the number of binary digits used in the mantissa.
The more bits, the smaller the error.
An equality comparison of two type double values can lead to unexpected results.
Example
for (count = 0.0; count != 10.0; count = count + 0.1) { }
Infinite loop

32. Cancellation Error
When you add a very large and a very small real numbers, the larger number may cancel out the smaller number.
Results in cancellation error.
Example: =
(On some computers)

33. Arithmetic Underflow
If we multiply two very small numbers, the result may be too small to be represented accurately.
The computational result will be represented by zero.
This phenomenon is called arithmetic underflow.

34. Arithmetic Overflow
If we multiply two very large numbers, the result may be too large to be represented.
This phenomenon is called arithmetic overflow.
Different C compilers handle it in different ways.

35. Automatic Conversion of Data Types
In several cases, data of one numeric type are automatically converted to another numeric type.
Some examples:
int k = 5, m = 4, n;
double x = 1.5, y = 2.1, z;
Expression of different numeric types:
k + x Value of int variable k is converted
Value is to type double format before operation is performed.
RHS is of type int and LHS is of type double:
z = k / m; Expression is evaluated first. Then, the result is converted to type double format for assignment.
Expression value = 1
z = 1.0

36. Automatic Conversion of Data Types
Example:
int k = 5, m = 4, n;
double x = 1.5, y = 2.1, z;
RHS is of type double and LHS is of type int:
n = x * y; Expression is evaluated first. Then, the result is converted to type int format for assignment, and fractional part is lost.
Expression value
= 3.15;
n = 3

37. Explicit Conversion of Data Types
C also provides an explicit type conversion operation called a cast.
Examples:
Using cast operation
int n1, n2;
double frac;
frac = (double)n1 / (double)n2;
2.0 / 4.0
0.5
Without cast operation
frac = n1 / n2;
2 / 4 integer division
Result:
frac = 0.5
Result:
frac = 0.0

38. Explicit Conversion of Data Types
A. frac = (double)(n1 / n2); and
B. frac = (double)n1 / (double)n2;
C. frac = (double)n1 /n2;
The quotient n1/n2 is computed first, results in loss of fractional part.
The cast to double convertsthe whole number quotient tp type dpouble.
frac = (double)n1 / (double)n2;
2.0 / 4.0
0.5
frac = (double)n1 / n2; n2 will automatically be converted to double.
Difference

39. Explicit Conversion of Data Types
Sometimes we include casts that do not affect the result but simply make clear to the reader the conversions that would occur automatically.
Example: int x, sqrt_x;
sqrt_x = (int)sqrt((double)x);
The formal parameter of sqrt function is of type double.
The actual argument x is of type int.
x will automatically be converted to type double.
sqrt function returns a value of type double.
This value will automatically be converted to type int since sqrt_x is of type int.
Note: When a cast operation is applied to a variable, the conversion changes the value of the expression, but it does not change what is stored in the variable.

40. Representation & Conversion of Type char
We can declare variable of type char to represent a single character
A character can be a letter, digit, or punctuation mark.
A character is enclosed in apostrophes.(e.g. ‘A’, ‘3’).
We can compare character values using equality operators (== and !=) and relational operators (<,<=, >, >=).
In ASCII (American Standard Code for Information Interchange):
digit character ‘0’ = 48 (decimal code value)
‘9’ = (‘0’<‘1’<‘2’<‘3’<‘4’…….<‘9’)
‘A’ = 65
‘Z’ = (‘A’< ‘B’<‘C’……..<‘X’<‘Y’<‘Z’)
‘a’ = 97
‘z’ = (‘a’< ‘b’<‘c’……..<‘x’<‘y’<‘z’)
C allows conversion of type char to type int and vice versa.

41. Enumerated Types
ANSI C allows us to associate a numeric code with each category by creating an enumerated type that has its own list of meaningful values.
typedef can be used to name user-defined types.
Example:
typedef enum
{ sunday, monday, tuesday, wednesday, thursday, friday,
saturday}
day_t;
enumerated type day_t has seven possible values (enumeration constants).
sunday will be represented as the integer 0, monday as integer 1, and so on.
day_t today; // declaration of variable today.

42. Examples of Enumerated Types
Class_t is an enumerated data type:
typedef enum
{fresh, soph, jr, sr}
class_t;
What is the value of each of the following?
(int) sr , (class_t) 0, (class_t)((int)soph + 1)
What is displayed by this code fragment?
for (class = fresh; class <= sr; ++class)
printf(“%d “, class);
fresh jr

43. Example of Enumerated Type
typedef enum
{ sunday, monday, tuesday, wednesday, thursday, friday,
saturday}
day_t;
day_t next(day_t today) {
day_t next;
if (today == saturday)
next = sunday;
else
next = (day_t)((int)today + 1);
return (next); }

44. Another Example of Enumerated Type
typedef enum
{ sunday, monday, tuesday, wednesday, thursday, friday,
saturday}
day_t;
void print_day (day_t day) {
switch (day)
case sunday:
printf(“sunday”);
break;
case monday:
printf(“monday”);
default: printf(“Invalid Code”); }