Hawassa University

School of Informatics, Computer Science Department

Revision on basic concepts on:

In theory, a variable is an abstract concept. It is a placeholder for a value used in some computation. In
implementation, a variable occupies a fixed storage. It is important to understand how variables differ in
storage because this affects how different variables can be used in different computations. It promotes
efficiency in programming by utilizing the correct data types, and hence the correct amount of memory
(using 64-bit variables to store whole numbers between 1 and 100 is a waste of space). It promotes correct
coding of arithmetic operations (coding floating point computations on whole numbers is a waste of time).
It leads to a better understanding of bitwise operations, which are critical for many computing algorithms,
such as in graphics. Finally, a proper understanding of memory helps in program design and debugging,
especially when more complex data types are used, such as arrays and pointers. This chapter, and the
following two chapters, all develop an understanding of C data types based upon an understanding of the
actual memory they occupy.

Bits, Bytes, and Data Types

Bit Models
In C, what is the difference between an int and a float? The simple answer is that one stores whole
numbers, whereas the other stores real numbers. But how? Or, how about some tougher questions: How
does a double store higherprecision numbers compared to a float? Does it double the numerical range of
possible values, or double the precision, or something else? How do the qualifiers short or unsigned change
the way a value is stored? In order to answer these questions, we have to understand the bit models that
underlie the data types.
A bit, short for binary digit, is a binary valued variable. The two possible values are typically written as 1
and 0, or true and false. On a computing chip (processor, memory chip, etc.), they are represented by high
and low voltages, where a high value is typically 1–5 V and a low value is typically 0.0–0.5 V.
Everything in computing is based upon combinations of bits. Everything stored in a computing chip is
based upon using a fixed number of bits to model (or represent) the thing of interest.

For our discussion, bits can be either 1 or 0. Since a single bit can only represent only two values, we
must group bits together to represent a wider range of numbers. The most common grouping is a byte,
which is 8 bits grouped in sequence. For example, the following is a byte:

When bits are grouped, there are a variety of methods for interpreting them collectively. Each method of
interpretation is called a bit model. We will now examine several bit models for representing various
types and ranges of numbers.

Magnitude Only Bit Model

The simplest bit model is for nonnegative whole numbers. In this case, each bit represents a nonnegative
integer power of 2. The place values of the bits are as follows:

1
 Hawassa University
School of Informatics, Computer Science Department

A bit value of 0 indicates a place value of 0; a bit value of 1 indicates a place value as given in the table.
The total value of the number represented is found by adding up the place values of all the bits. In the
example above, the value represented in the 8 bits (1 byte) is 19:

Sign Magnitude Bit Model

In the case where signed whole numbers are desired, a common practice is to allocate the highest-order
bit to be the sign bit. This is called the sign-magnitude model:

By common convention, a value of 0 in the sign bit indicates a positive number, while a value of 1 in the
sign bit indicates a negative number. In this example, the decimal value represented using the 8 bits is
−19. Using the sign-magnitude bit model, it is possible with 8 bits to represent whole numbers in the
range −127 to +127.
The sign-magnitude model suffers from two drawbacks. First, notice that there are two possible bit values
for zero: 00000000 can be interpreted as “positive zero,” while 10000000 is interpreted as “negative
zero.” This does not make much sense. Even more important, using this bit model makes binary addition
somewhat complicated.

Two’s Compliment Bit Model

Using the two’s complement bit model, positive integers (and zero) are represented exactly the same as
they are in the magnitude-only bit model. Negative numbers are represented by applying the following
sequence of steps:
1. Write the bits for the positive version of the number.
2. Invert (flip) all the bits.
3. Add 1.
For example, to represent −7, we proceed through the following steps:

When a two’s complement number has a 1 in the highest bit, it indicates that the number is negative. To
find the value, we perform the same steps:

After performing these steps, the value provides the magnitude of the negative number. In this example,
we get a magnitude of 7, so the original bit pattern 11111001 is known to be −7.

Floating Point Bit Model

For storing real numbers, a method completely different from the previous bit models must be used. Some
of the bits must be used to represent the fractional portion of the number. One possibility is to use bits to

2
 Hawassa University
School of Informatics, Computer Science Department

denote powers of 2 that are negative, and hence fractions. For example, we could use 1 byte (8 bits) as
follows:

This approach is called a fixed point bit model, because the position of the number of digits (in base 10)
that can be represented in the fraction are fixed. In our example, the base 10 value that is represented by
the 8 bits is 18.375. In this example, only three fractional digits of a base 10 number can be represented.
This is generally considered a limitation, and a poor use of available bits.
The following example demonstrates these steps. The value −118.625 will be encoded:

The exponent is biased by adding 127 so that the exponent can be stored as a mangnitude-only, and yet
still represent the range −127 to +128. For our example, the final 32-bit floating point representation is:

Note that the spaces are for our convenience only; they are not represented in any way in the computing
system. The following are some additional examples:

ASCII and Unicode Bit Models

In order to represent nonnumeric data, another bit model must be used. The ASCII (American Standard
Code for Information Interchange) bit model was developed to represent English text symbols, along with
control characters necessary to print English text. A partial listing of the ASCII bit model is shown in
Table 2.1 (a full listing is in Appendix A). There are 128 total ASCII bit patterns. Each bit pattern uses 7
bits. In order to fill a byte, an eighth bit is added to each pattern. Historically, this extra bit has been used
for several purposes, such as parity (a form of error recovery) and extended ASCII sets (providing an
additional 128 bit patterns). However, it is also common to leave the bit with a value of zero, in effect
padding the 7-bit ASCII patterns with a preceding zero. Most of the bit patterns in ASCII represent
printable symbols, such as the lowercase versions of letters in the English alphabet. The patterns for both
the lower- and uppercase letters are stored in order, from 97 to 122 and from 65 to 90, respectively. The
first 32 bit patterns (from 0000 0000 to 0000 1000) represent control characters, which do not correspond
to printable symbols. Instead, these characters control some aspect of printing, such as a backspace,
horizontal tab, or carriage return.

In C, both the char and unsigned char data types use the ASCII bit model. However, because of their 7-bit
nature, the eighth bit allows for a second, different use of each data type. If we interpret each of the bit

3
 Hawassa University
School of Informatics, Computer Science Department

patterns as magnitudeonly whole numbers, then we obtain the base 10 values listed in Table 2.1. The
unsigned char data type can be interpreted in this manner, providing a range of values from 0 to 255. If we
interpret each of the bit patterns using the two’s complement bit model, then we obtain base 10 values in
the range −128 to +127. The char data type can be interpreted in this manner. This dual interpretation of
the bit patterns can be seen through the following C code:

char a; printf("%c %c %d %d\n",a,b,a,b);

unsigned char b; a=183;
a=’A’; b=255;
b=’B’; printf("%d %d\n",a,b);
A common pitfall for naive programmers is to use the wrong data type for the given data or computation.
This amounts to using the wrong bit model, with consequences similar to opening a random file using a
text editor. When seeing a value that looks very strange (i.e., garbage), one should look to make sure the
correct data type is being used. The reason for type casting computations to use the same data type is to
ensure that all the variables involved are using the same bit model.
For example:
int i=3;
double d=7.2;
float f;
f=(float)i+(float)d;

While programming, even when it is not necessary to understand how the individual bits are organized in
variables, it is often important to understand how many bytes are used by variables. The sizeof() operator
reports how many bytes a data type, or a variable, is using:

int i;
char c;
double d;
printf("%d %d %d %d\n",sizeof(i),sizeof(c),
sizeof(d),sizeof(float));
The result of executing this code is:
4184

Arrays, Strings, Pointers and Structures

Beyond the four basic data types (char, int, float, double), the C language supports some advanced data
constructs. These include arrays, strings, pointers and structures. Like the basic data types, each of these
advanced data constructs is intended to store something different:

An array is intended to group together a list of values, all of the same type, under one variable name. It is
much easier to code computations on an array than on a list of independently named variables:
for (i=0; i<100; i++) /* array coding */
sum=sum+qty[i];
sum=qty1+qty2+qty3+... /* without an array */

A structure is intended to group together an assortment of values of different types under a single variable
name. Like an array, it makes it easier to code computations. A string is intended to group together a

4
 Hawassa University
School of Informatics, Computer Science Department

series of character symbols under one variable name. It is closely related to an array, but because it is
intended only for text data, a number of functions have been crafted to perform text-specific operations on
strings. A pointer is intended to hold the address of another variable, to provide a “gateway” or path of
indirect access to the other variable. It is used most often in passing values between pieces of code
(functions).

Array:
An array is a construct used to store a set of values using only one variable name. Each of the values
occupies a cell. Every cell in the array is the same size, meaning it occupies the same amount of memory.
The size of each cell is dictated by the data type (char, int, float, double) given in the variable declaration.
The number of cells is also given in the variable declaration. Here are some examples:

int a[2]; /* 2 cells, each cell 4 bytes (32 bits) */

float b[3]; /* 3 cells, each cell 4 bytes (32 bits) */
double c[4]; /* 4 cells, each cell 8 bytes (64 bits) */
char d[5]; /* 5 cells, each cell 1 bytes (8 bits) */

Faulty addressing can lead to another type of crash called a bus error. A bus error occurs when a program
tries to access a memory address that is physically impossible (or nonexistant).

Read further about memory map.

Why does the C compiler allow out-of-bounds array accesses?

Multidimensional Array
Arrays in C can have more than one dimension. But computer memory is all arranged in one-dimensional
order, as though it were one long street of bytes. How then are multidimensional arrays stored in
computer memory? Does a computing system have some other strange, multidimensional space for use
only by these arrays? Of course not. The answer is that the cells in the multidimensional array are listed
out, one at a time, in one-dimensional order. For example, consider the following code:

int a[3][2];
a[0][1]=7;
a[1][0]=13;

Strings
A string is a specific type of array: it is an array of char, containing a sequence of values where a value of
’\0’ signifies the end of the string. Although the array could be of any size, it is assumed that the valid data
in the array starts at the first cell, and ends with the first cell having a value of ’\0’. For example:

char d[8];
d[0]=’H’; d[1]=’e’; d[2]=’l’; d[3]=’l’; d[4]=’o’;
d[5]=’\0’; /* ’\0’ indicates the end of string */

Multidimensional strings
One of the common uses for multidimensional arrays is to store a list of strings. Since each string is a
one-dimensional array, a list of strings requires a twodimensional array. For example:

char n[2][4];
n[0][0]=’T’; n[0][1]=’o’; n[0][2]=’m’; n[0][3]=0;
n[1][0]=’S’; n[1][1]=’u’; n[1][2]=’e’; n[1][3]=0;

5
 Hawassa University
School of Informatics, Computer Science Department

String Library function

There are a handful of calculations that are common to a large number of text processing problems. These
calculations include finding the length of a string and comparing the contents of two strings. Because they
are so common, the C standard library has evolved to include functions to perform these calculations.
There are five functions that cover the most common calcuations and operations:

We used the memory map to study how arrays and strings work. Writing out a memory map is often
useful during program design. During debugging, it can be invaluable. In this chapter, we extend these
ideas to pointers and structures. All variables have an address in memory, much the same way that all
houses and businesses have a street address in the real world. However, the organization of buildings and
streets becomes clearer by looking at a map. It tends to be easier to explore an unknown city or to reach a
destination using a map. In much the same way, it tends to be easier to design code for a problem
involving pointers or to debug the code using a memory map. Pointers (and to some degree, structures)
can be the most difficult tool to master in the C programming language. The goal of this chapter is to
increase the proficiency of the reader with these tools through a deeper understanding of how they work.

Pointers
A pointer is a construct used to store an address of a variable. We declare a variable to be a pointer-type
variable by preceding its name with the asterisk symbol (*). For example:
char c,*cp;
int i,*ip;
float f,*fp;
double d,*dp;

The variables c, i, f, and d are normal variables, each holding a different type of value. The variables cp,
ip, fp, and dp are all pointers, each holding an address.
Read more about How many bytes does a pointer use?

Structure
A structure is a construct used to group a set of variables together under one name. The first step in using
a structure is to declare its organization. For example:
struct person { /* "person" is name for structure type */
char first[32]; /* first field is array of char */
char last[32]; /* second field is array of char */
int year; /* third field is int */
double ppg; /* fourth field is double */
}; /* ending ; to end definition */
This code does not create a variable. There are no bytes of storage named yet. Instead, this code creates a
template for a new variable type called struct person. One can think of a struct person as being a similar

6
 Hawassa University
School of Informatics, Computer Science Department

construct to an int or double. It is a name for a data type, not a name for a variable. In this example, the
struct person consists of two arrays of 32 char, an int, and a double, for a total of 76 bytes.

We can use this definition of a struct person to declare a variable as follows:

struct person teacher;
We now have a variable named teacher that provides 76 bytes of storage. Each part of the variable is
called a field and is accessed using the period (.) symbol. For example:
teacher.year=2006;
teacher.ppg=10.4;
strcpy(teacher.first,"Adam");
strcpy(teacher.last,"Hoover");

Arrays and structure

It is possible to create an array of structs, just like it is possible to have an array of any data type. The
template for the structure definition remains unchanged; it still must be declared first. Using our definition
of a struct person from above, we may write the following code:
struct person class[54]; /* array of "struct person" */ strcpy(class[0].last,"Doe");
class[0].year=2006; /* notice where array class[1].first[0]=’B’; /* array field in a struct array */
subscript goes */ class[1].first[1]=’o’;
class[0].ppg=5.2; class[1].first[2]=’b’;
strcpy(class[0].first,"Jane"); class[1].first[3]=0;

Input/ Output
It is assumed that the reader is familiar with basic user I/O, such as reading input from a keyboard and
printing text to a terminal display. The reader is likely also familiar with basic file I/O, such as reading
and writing text to a file. It is common for a student to first learn text-based I/O; unfortunately, this can
bias the student toward thinking of all I/O as text-based. The goal of this chapter is to provide a broader
picture into the aspects of generic I/O. It is important to remember that text is only one type of data. When
considering generic I/O, we should remember to think of the data as raw bytes. It is up to the sender or
receiver of the data to interpret the bytes.

Streams, Buffers
An I/O transaction occurs when a program receives bytes from a source or sends bytes to a destination.
Example sources that send bytes to a program include a keyboard, mouse, file, and sensor. Example
destinations to which a program sends bytes include a display, file, printer, and actuator. Programs can
also send bytes to other programs, acting as sources or destinations.

Most modern operating systems, including Unix, use the stream model to control I/O. In this model, any
input or output transaction can be viewed as a flow of bytes from a source to a destination. The flow of
bytes is commonly referred to as a stream. The operating system creates and manages streams based upon
the function calls made by the program. The program has some control over how the stream is operated,
but in general it is managed by the operating system.

Transporting Bytes on Streams

There are several functions that can be used to transport bytes on streams. These include the familiar
fprintf() and fscanf() functions. For example:
#include <stdio.h>
main()

7
 Hawassa University
School of Informatics, Computer Science Department

{
FILE *fpt;
fpt=fopen("data.txt","w");
fprintf(fpt,"Fortytwo 42 bytes of data on the wall...");
fclose(fpt);
}

System I/O Functions

There is another set of functions that can be used for I/O. These functions include open(), close(), read(),
and write(). They look very similar to the fopen(), fclose(), fread(), and fwrite() functions just discussed.
How then are the non-f-versions of the I/O functions different from the f-versions?

The non-f I/O functions are system calls. Depending on which operating system they are called from, they
may behave differently. The f-versions of the I/O functions are standardized in the C library. A
programmer can expect them to behave similarly regardless of the underlying system. Unless otherwise
motivated, a programmer is encouraged to always use the f-versions of the I/O functions.

A general rule of thumb is that the f-versions of the I/O functions are buffered, while the non-f-versions
are not (buffers will be discussed shortly). This is not always true, as some system implementations of I/O
functions may include buffering. However, in practice a programmer can expect to frequently encounter
this distinction.

The standard streams are most commonly used by calling the scanf() and printf() functions. The scanf()
function is actually a specialized version of the more generic fscanf() function. While the fscanf()
function can receive bytes from any stream, the scanf() function is “hardwired” to the stdin stream. In the
following example, the scanf() and fscanf() function calls perform the exact same operation:
char s[80];
scanf("%s",s);
fscanf(stdin,"%s",s);
The same is true with regards to printf() and fprintf(). While the fprintf() function can send bytes along
any stream, the printf() function is hardwired to the stdout stream. In the following example, the printf()
and fprintf() function calls perform the exact same operation:

8
 Hawassa University
School of Informatics, Computer Science Department

Buffers
A buffer is a temporary storage between the sender and receiver of bytes on a stream. When a stream is
created, one can think of it as having an address from which bytes are sent and an address at which bytes
are received. Each address is at a memory location controlled by the operating system. The buffer is an
additional piece of memory that is used to moderate the flow of bytes from the source to the destination.

A buffer is useful in a variety of situations. For example, what if the sender puts bytes into the stream
faster than the receiver can handle? Or what if a program is in the middle of a calculation and is not
prepared to receive any bytes? The buffer can store up the bytes until the program is able to handle them,
receiving them either at the reduced rate or when it is ready for them.

There are three basic types of buffering: block buffering, line buffering, and unbuffered. They differ in
how the temporary storage is flushed. Flushing is the act of emptying out the temporary storage, sending
all the bytes in the buffer on down the stream to the receiver. Each type of buffering differs as to how it
flushes. In a block buffer, a fixed-size chunk of memory is filled before being passed on to the receiver. A
block can be any size, although byte sizes that are powers of 2 are typical (e.g., 1 KB, 16 KB, etc.). In a
line buffer, any bytes inside the buffer are sent to the receiver once a newline character (byte value of 13)
is received. The newline character is also sent to the receiver. Finally, if the stream is unbuffered, then
each byte is sent to the receiver as soon as it is placed in the buffer. The buffer operates as though it is
transparent.

Block buffering is commonly used for large data transfers, such as file I/O. It makes the transfer more
efficient by saving up a large number of bytes before actually transporting them. If a program is doing a
lot of large data transfers, block buffering will speed it up. Line buffering is typically used for text-based
I/O, such as when interacting with a user. It allows bytes to be modified before actually committing them
to the stream transport. For example, a delete or backspace key can be used to modify the bytes in the line
buffer, while the enter key can be used to initiate the flush. Finally, buffering may be completely turned
off when responsiveness is critical. For example, a program may want to take action after any keypress
provided by the user, without having to wait for flushing. In this case, the input stream would likely be
unbuffered.

Pipes, Files
Pipes
The term pipe is used in several contexts in I/O. Sometimes, the word “pipe” is used interchangeably with
“stream” to refer to a flow of bytes between a source and destination. More often, it is used in contexts
where streams are reconnected to alternate sources or destinations. An analogy to plumbing can be made
as follows: imagine a water pipe that is disconnected at its source but left connected at its other end. The
disconnected end is then reconnected to an alternate source. By modeling a stream on this concept, one
can think of the connections at stream ends as pipe fittings. The process of connecting and reconnecting
streams is referred to as piping, or pipelining. The analogy also extends to replacing a single pipe-to-pipe
fitting with a three-way fitting, connecting one source to two destinations. One can imagine reconnecting
the standard out stream so that it simultaneously sends the same bytes to a file and a display. This is
another example of piping.

Pipelining the output of one program to the input of another program can be done repeatedly. This allows
us to write programs that perform single, simple operations, and to link them together into complex
chains in order to accomplish tasks.

9
 Hawassa University
School of Informatics, Computer Science Department

Files
Every computer user is familiar with files, but what exactly is a file? A file is a one-dimensional array of
bytes. Regardless of what sort of data is inside the file, it is always stored as a one-dimensional array of
bytes. This may seem counterintuitive for a file that contains an image, or a movie, or a database. An
image, movie, or database can be stored as a one-dimensional array of bytes by writing all the elements
out in a long list. Furthermore, it does not matter what sort of data is inside the file. If the file contains
text, an image, a song, or an executable program, it is still a one-dimensional array of bytes. The
difference is only in which bit model was used to group and encode the bytes. Therefore, when we think
of reading from or writing to a file, we can always consider the process as being similar to accessing a
one-dimensional array of bytes.

One of the jobs of an operating system is to manage file storage. A system typically provides a set of
function calls, for use by programs, to interact with files. These include the operations already examined,
such as the ability to read and write data, plus additional operations. We will explore these additional
operations and related functions as we discuss each associated topic.

File Pointer
A file pointer is a marker used to keep track of the location for reading or writing on a stream. When a file
is opened, the file pointer points to the first byte in the file. Each time a byte is read, the file pointer is
automatically advanced to the next byte. If multiple bytes are read, then the file pointer is advanced
beyond all the bytes that have been read.

10