114 Chapter 2 Advanced C Topics

will cause the data to be printed to the left edge of the field. Other­ wise, the data will print to the extreme right edge of the field.

Formatted input is also provided in C. The three formatted input functions are

int scanf(char* format,arg1,arg2,...); int sscanf(char* string,char* format,arg1,arg2,...);

int fscanf(FILE* fp,char* format,arg1,arg2,...);

The first of these functions reads formatted data from the standard input, the second reads formatted data from a string in memory, and the third reads formatted data from an open file fp. There is a sig­ nificant difference between the formatted inputs and outputs. Recall that the arguments in the formatted outputs are data values. In the formatted inputs, all arguments must be pointers to locations in memory that can hold the data types specified in the data string. If the program should contain

int i;

.

.

.

scanf(“%d”,i); /* BAD */

the program will probably compile, the compilers will not note an error, and the program will crash because the scanf() argument is not a pointer. It is generally recommended that you avoid use of the scanf() function.

Memory Management

There are two functions in C that allow dynamic memory man­ agement. The function

void* malloc(size_t n);

returns a pointer to a block of memory that is n bytes long. This memory is uninitialized. malloc() (and calloc() below) re­ turns a pointer to a block of memory of the type void. Therefore, before it can be used, the return pointer must be cast onto the data type that the program requires. In this case, an assignment of the return value to a pointer of the correct type will work. If this step is

Memory Management 115

not taken, none of the usual pointer arithmetic will work. If the memory is not available to be allocated, the allocation program will return a NULL.

A second dynamic memory allocation function is

void* calloc(int number, size_t n);

This function returns a pointer to a type void. It takes two arguments. The first argument is the number of items and the second argument is the size of the specific item. Therefore, if you wished to allocate space for ten TNODEs from the above problem, you should use

(TNODE *) calloc(10, sizeof(TNODE));

calloc() differs from malloc() in that it returns a pointer to initialized space. The calloc() function initializes all memory assigned by the function to zero. When memory is allocated by ei­ ther malloc() or calloc(), this memory must be returned to the system. If allocated memory is not returned to the system, even­ tually all of the available memory will be allocated. Further attempts to allocate memory will fail. If the return pointer from the allocation function is not tested and properly handled when a NULL is returned, the program will exhibit undefined behavior. This problem can be avoided by deallocating memory when it is no longer needed by the program. The function

void free(void* );

will release allocated memory. The argument in this case must be a pointer that was returned from an allocate function, either malloc() or calloc().

An additional memory allocation function is

void *realloc(void *,size_t);

The first parameter here is a pointer to a previously allocated memory block, and the second is the new size that you want for the allocated memory. This function will change the size of the allocated memory block. If you are reducing the size of the block, the pointer returned will probably be the same as that passed to realloc. If you are increasing the size of the block, and there is not enough contiguous memory available, the function will search for a proper sized block.

116 Chapter 2 Advanced C Topics

If one is found, the data stored in the original block are copied to the new block and the proper space is allocated. The pointer returned in this case will not be the same as that passed.

Miscellaneous Functions

C provides several sets of miscellaneous functions that are very useful. As mentioned earlier, the input/output functions that are prototyped in stdio.h are not parts of the language, but instead are separate functions. The miscellaneous functions are prototyped is several different header files. Many of these functions are macros, and if they are, the macro definitions are contained in the header file.

Following is a list of several header files specified by the ANSI Standard. With each header file is a list of functions or function pro­ totypes contained within these files. You should look to the documentation for your compiler to get the detailed descriptions of each of these files.

As mentioned earlier, these files are there, tested, work and are probably as robust and reliable as any code written. They do what they are supposed to, and they are free. It makes little sense to re­ write these programs just to satisfy an ego trip. I have seen shop coding standards that did not allow the use of standard library files because the programmers could not examine the source code. Such a standard is absolutely silly. If you do not trust the compiler to pro­ vide safe, satisfactory library code, you should not trust the compiler to generate any code. Therefore, you are using the wrong compiler. Get a compiler that meets your standard.

Most embedded programs that employ microcontrollers do not have standard connections to input/output devices. For example, there is rarely a terminal or a keyboard attached to an embedded system. More likely you would expect to find a numeric, or special, keypad and an LCD special purpose output display. None of the standard i/o programs can connect with such devices. In such cases, it will be your responsibility as the programmer to write drivers to interface with these devices. Also, you will rarely see disk files in your em­ bedded product. Therefore, you will rarely need to include the header file stdio.h in a microcontroller program.

CHARACTER TESTS—in ctype.h

isalpha(c) non-zero if c is alphabetic, 0 if not isupper(c) non-zero if c is uppercase, 0 if not islower(c) non-zero if c is lowercase, 0 if not isdigit(c) non-zero if c is a digit, 0 if not isxdigit(c) non-zero if c is a hexadecimal digit, 0 if not isalnum(c) non-zero if c is a digit or alphabetic, zero if not isspace(c) non-zero if c is a blank, tab, newline,

return, formfeed, vertical tab, 0 if not ispunct(c) non-zero if c is a printing character except

space, letter, or digit

iscntrl(c) non-zero if c is a control character, 0 if not isgraph(c) non-zero if printing character except space isprint(c) non-zero if printing character including space toupper(c) return c converted to upper case tolower(c) return c converted to lower case

MATH FUNCTIONS—in math.h

118 Chapter 2 Advanced C Topics

frexp(x,int *exp) split double into mantissa and exponent modf(x,double *ip) Splits x into integral and fractional parts. Puts integral in ip and returns

fractional part. fmod(x,y) floating-point remainder of x/y

These functions all require double arguments and return double values.

Utility functions—in stdlib.h

double atof(const char *s); integer atoi(const char *s); long atol(const char *s);

double strtod(char *str,char **scanstop); long strtol(char *str,char **scanstop,int base);

unsigned long strtoul(char *str,char **scanstop,int base); ldiv_t ldiv(long numer,long denom);

div_t div(int numer,int denom); long labs(long n);

int abs(int n);

void *bsearch(void *key, void *base,size_t number,size_t size, int(*compare)(void*,void*));

void qsort(void *base,size_t number, size_t size, int(*compare)(void*,void*));

int rand(void);

int srand(unsigned int seed);

void *calloc(size_t nobj, size_t size); void *malloc(size_t size);

void *realloc(void *p, size_t size);

void free(void *p); void abort(void);

int atexit(void(*fcn)(void)); void exit(int status);

int system(const char *name);

Non-local Jumps—in setjmp.h

int setjmp(env);

int longjmp(env,int);

Diagnostics—in assert.h

The macro assert() is defined in assert.h

Signals— in signal.h

void (*signal(int sig, void (*sighandler)(int)))(int); int raise(int sig);

Date and Time Functions —in time.h

char *asctime(struct tm *timeptr); clock_t clock(void);

char *ctime(time_t *timer);

double difftime(time_t time2, time_t time1); struct tm *gmtime(time_t *timer);

struct tm *localtime(time_t *timer); time_t mktime(struct tm *timeptr);

size_t strftime(char *buffer, size_t bufsize, char *format, struct tm *timeptr);

time_t time(time_t *timer);

Standard input and output—in stdio.h

120 Chapter 2 Advanced C Topics

As you scan through the above listings, you will see many types that are not from the usual list of available types. Whenever you find such a type, the type will be either a typedef of a structure or a typedef of a standard type. These typedefs will be found in the header file where they are used.