Advanced C 1992

Part II • Managing Data in C

Listing 8.4. continued

nArray[i + 6], nArray[i + 6], nArray[i + 7], nArray[i + 8], nArray[i + 9]);

}

free(nArray);

return(0);

}

int compare( const void * a, const void * b)

{

return (*(int *)a - *(int *)b);

}

SORTALOC illustrates several important points about using the memory allocation functions. First, the array is simply declared as an integer pointer called nArray. This pointer is initialized with NULL to prevent an error when the free() function frees the pointer. Although always initializing variables may seem excessive, using an uninitialized variable is a common programming error.

After calloc() allocates the array, it can be accessed in the same way as any other array. For example, standard array indexing can be used, as shown in the following:

for (i = 0; i < nArraySize; i++)

{

nArray[i] = rand();

}

The loop assigns a random number to each element (indexed by i).

After the array is filled, it is passed to the qsort() function like any other array. The qsort() function can sort almost any type of data. You just give qsort() the size of the array’s elements, the number of elements, and the compare function. (Note: The compare function in Listing 8.4 is valid for integers but not floating-point values.

246

This is because the compare must return an integer, and a floating-point value may differ by less than the truncation value of an integer.)

Finally, the array is printed in ten columns. There is nothing tricky about this portion of the code—one print statement prints ten elements, then the index is incremented by ten.

Global Memory versus Local Memory

The discussion of local memory and global memory is applicable to computers with Intel 80x86 CPUs. These CPUs use segmented architecture, in which a data object can be addressed with a full address (consisting of both a segment and an offset from the segment) or as an offset (where the segment used is the default data segment).

Not all operating systems and compilers offer access to both local memory (found in the default data segment) and global memory (located outside the default data segment, usually in its own segment). A compiler that offers memory models, such as small, medium, large, and compact, is generally found on a PC-type of computer. The discussion in this section pertains to compilers used on an 80x86 CPU.

For most compilers, the memory model determines the area from which memory will be allocated. If your program uses the large or compact memory model, the default memory pool is global. If your program is a small or medium model program, the default memory pool is local. You can always override the compiler’s default memory allocation area.

When running in real mode, Intel 80x86 CPUs can access a maximum of 64K in each segment. This limitation, and the way the default data segment is allocated (it is often used for the stack, initialized data variables, constants, literals, and the heap, which is where memory is allocated from when using local memory), affects how much data a program can have.

Global memory has its own segment, and thus can have up to 64K in a single data object (or more than 64K by using several contiguous segments). To use global memory, however, your program must use far (4-byte) pointers rather than near (2- byte) pointers, and this can slow program execution. If you need to determine the effect this has on performance, you could create one version of your program with small data blocks and near pointers, and the other with large data blocks and far pointers, then run simple benchmarks.

247

Part II • Managing Data in C

Summary

In this chapter, you learned about memory allocation, how to change the size of an allocated block of memory, and how to free memory after it is no longer needed.

•The malloc() function is the ANSI standard method for allocating memory. It accepts a single parameter that specifies how much memory should be allocated.

•The calloc() function allocates memory based on the size of the object and the number of objects. It is typically used to allocate an array.

•When memory allocated with one of the memory allocation functions is no longer needed, the free() function returns the memory to the operating system.

•The realloc() function changes the size of a block of memory allocated with one of the memory allocation functions. The object’s size can be increased or decreased.

•When programming on the PC (and other systems), you can often choose the size of the pointer that accesses the allocated memory. The pointer size affects the size of the executable program and the performance of the program.

248

CDisk FilesCand Other I/O CC C C

C9C C

9 C C C

C C C

C C C

Disk Files and Other I/O

Without files, your program could do nothing. It would be without input, unable to provide output, and unable to save the result of any of its computations. Fortunately, ANSI C offers an excellent collection of file I/O functions. You can write to a file in an unformatted (machine readable) manner, or your program can write to a file in a formatted (people readable) manner.

This chapter deals with all types of I/O: to and from files, the console, and other devices. You learn all (at least I hope all) that you will need to develop the I/O portions of your programs. The first part of this chapter deals with disk files. The second part covers console I/O and direct port I/O, including I/O to printer ports and communications ports. Much of the direct port I/O is hardware dependent; the discussion applies to a PC-based system.

249

Part II • Managing Data in C

File I/O Basics

This section does not discuss how files are arranged, stored, and managed on the disk drive. That is a topic for a book on operating systems, not a book on C programming. This section does cover how to use files.

The most important part of most programs is their capability to save results or the data they use (such as a database) to a disk file. All disk files share things in common. (Again, this discussion is confined to the PC’s DOS operating system.)

All files have names. The format for a disk filename is eight characters for the name and three characters for the extension. The selection of a file’s name and extension are generally left to the user, except for files that other applications utilize. Many applications suggest an extension (some require it), but few programs place restrictions on the name.

All files have a creation date and time, which is stored in the time stamp. The time stamp is updated each time you save changes to the file, so it serves as a file modification time stamp.

All files have a length. This length is in the operating system’s structure saved for each file. When a file consists of only text, it may also contain an EOF (end of file) marker, which under DOS is 0x1A (Ctrl-Z).

All files also have attributes, as follows:

250

You can specify the read-only attribute when you create a file. All other attributes must be set (or cleared) using the DOS ATTRIB command. You use the system() function to call the ATTRIB command from DOS applications.

When a file is opened, the program typically must specify the filename and the mode: read, write, or both read and write. If the file is being created, the program could specify also whether the file will be read only after it is created.

The open functions return an identifier that is a file handle or a pointer to the opened file. You use this identifier when you call the read and write functions. When the program has finished with the file, the file should be closed, or if it is a temporary work file, deleted.

Text Files and Binary Files

If a text file is displayed on the screen, it is readable. It shouldn’t contain any special characters other than tabs and newlines and is generally formatted so that it presents information to the user in an organized manner. Many text files are used only by programs, however, even though the files are fully readable (and perhaps even understandable). A binary file can contain any data, including the internal representation of numbers, special control characters.

A problem arises when you use a text file, the C language, and C’s interface to DOS. C specifies a single character (called the newline character) to signify the end of a line. DOS uses two characters (a newline character followed by a carriage return character) to signify the end of a line. Each is a control character, and as such, must be specified using the ANSI C escape sequence, which begins with a backslash character.

To specify a newline, you use the \n character sequence. When C encounters the newline character in a string being output to DOS (either to a file or on the screen), C converts it to the two-character sequence that DOS expects (a newline followed by a carriage return). When input is read, C does the opposite, converting the newline and carriage return pair to a single newline character.

This creates a minor problem. When the program reads a specified number of bytes in a text mode file, each time the newline and carriage return pair is encountered, the character count is incremented by only 1 (only one newline character is counted). If your program reads the string from a file, as shown in Figure 9.1, the string is only 29 characters long, not the 31 characters stored in the file.

251

Part II • Managing Data in C

Figure 9.1. A string in memory and in a text mode file.

The problem arises when the program must go (seek) to a specific place in the file. You cannot assume how many characters (or bytes) are between a given point and the desired point. If you have written a file containing five different strings that are each 50 characters long (and contain an unknown number of newline characters), you could not get to the beginning of the fourth string, for example, by seeking to character number 150.

To successfully seek in a text file, you must create an index to each string (or record). This index is assigned values by using one of the functions that return the current place in a file, such as ftell() or fgetpos(). These functions return the correct position of a given data object, taking into consideration the conversion of the newline character to a newline and carriage return pair.

You must save this index to be able to access the strings randomly. The only alternative to saving an index is to read the text file sequentially, which may not be acceptable based on performance considerations.

The TEXTFILE.C program, shown in Listing 9.1, shows the effects of text mode.

Listing 9.1. TEXTFILE.C.

/* TEXTFILE, written 1992 by Peter D. Hipson

*This program demonstrates text file

*newline conversions.

252

int main(void); // Define main() and the fact that this program // does not use any passed parameters

int main()

continues

253

Part II • Managing Data in C

Listing 9.1. continued

while (DataFile == NULL)

{

while(szMode[1] != ‘b’ && szMode[1] != ‘t’)

{

printf(“\nPlease enter ‘t’ for text file, ‘b’ for binary: “);

/* For non-Microsoft C systems, use tolower() (no leading underscore) */

szMode[1] = _tolower(getche());

}

printf(“\nPlease enter name of file to write: “);

gets(szFileName);

DataFile = fopen(szFileName, szMode);

if (DataFile == NULL)

{

printf(“ERROR: File ‘%s’ couldn’t be opened.\n”, szFileName);

}

}

printf(“\n”);

switch(szMode[1])

{

case ‘t’:

254

255