This function provides the framework for altering the locale, without defining the specific values. The locale variable could be something like "English.USA" or "English.England". Compiler manufacturers may or may not provide other locales. If they do not, it is difficult to make use of this function, as different locales alter the operation of other ANSI functions, for which you do not have source.

The localeconv function returns a pointer to a structure of type lconv. This structure contains various values that are specific to the current locale. They include the decimal-point character, currency symbols (local and international), and information on how the currency symbol and positive and negative values are displayed. For example, in Norway, a positive currency is shown as "kr1.234,56" and a negative currency as "kr1.234,56-". Italian lira amounts are shown as "L1.234" and "-L.1.234". The currency amounts are not automatically formatted for you. You will need to write or obtain a function that can use the information returned by localeconv to produce the correct output.

You can modify particular parts of the locale by using different options for the first parameter. The LC_NUMERIC option affects the decimal point character in other functions, such as printf and scanf and the information returned by localeconv. LC_MONETARY alters the information returned by localeconv. LC_TIME affects the output of strftime. LC_COLLATE alters the operation of strcoll and strxfrm. LC_TYPE changes the operation of the character functions.

size_t strftime
   ( char *output_string,
   size_t output_string_size,
   const char *format,
   const struct tm *p_time);

strcoll and strxfrm are used to compare and translate strings that contain characters other than the standard seven-bit ASCII set. They may also be used to sequence ASCII characters in non-ASCII order. strcoll works like strcmp, but it uses character comparisons that are based on the locale. For example, characters with accent marks, e.g. , may be interpreted as greater than the non-accented character e and less than the character f. This comparison involves some sort of table lookup or other algorithmic method, rather than a simple subtraction of two chars. Using this in place of strcmp for qsort may increase the sort time substantially. Its prototype looks exactly like strcmp:

int strcoll(const char *string_1,
   const char *string_2);

size_t strxfrm
   (char *transformed_string,
   const char *input_string,
   size_t input_string_size);

The character functions, such as isalpha and isupper, return true or false values, depending on the value of the character passed to them. Regardless of whether you have ever considered going international, you should be using these functions. You may have coded if (c >= 'A' && c <= 'Z') to test for upper case characters. That is essentially non-portable to non-ASCII computers. Although only an estimated .1 percent of computers use a code other than ASCII, for completeness, consider the possibility. Additionally, using isalpha and other functions makes your code more readable and possibly faster. These functions use the locale information to determine the type of characters. So isalpha would return true for .

 int (*pointer_to_function)();

int a_function(int one_parameter);
double another_function
   (int first_parameter,
   int second_parameter);
int still_another_function
   (int first_parameter,
   int second_parameter);

pointer_to_function = a_function;

pointer_to_function = still_another_function;

pointer_to_function = another_function;

int (*pointer_to_function_with_one_int)(int);

pointer_to_function_with_one_int = a_function;

pointer_to_function_with_one_int = still_another_function;

a_fourth_function (double one_parameter);

pointer_to_function_with_one_int = a_fourth_function;

int (*pointer_to_function_with_double)(double);

pointer_to_function_with_double = a_fourth_function;

pointer_to_function_with_int = (int (*)(int)) a_fourth_function;

Given that background in pointers to functions, there are at least three common places where they are used in code. The first is a parameter to qsort. The qsort function sorts an array of values based upon a comparison function. Its prototype is:

void qsort(void *array, size_t number_elements,
   size_t size_of_element,
   int (*compare_function)( const void *, const void *));

your_compare_function(int * first, int * second)
/* Quick compare - may not work for all int values */
   {
   return *first - *second;
   }

#define NUMBER_ELEMENTS 10
int int_array[NUMBER_ELEMENTS] = {5,3,4,6,7,1,2,3,4,7};
qsort (int_array, NUMBER_ELEMENTS,
   sizeof(int), (int (*)(const void *, const void *))
   your_compare_function);

your_comparison_function(void *first, void *second)
   {
   return *(int*)first - *(int*)second
   }

The next area in which function pointers have been used extensively is with device drivers. I'll cover this in general, since they vary from operating system to operating system. A device driver responds to requests from the operating system for opens, reads, and writes. To install a device driver, you usually set up a system defined structure or array that looks like:

struct s_device_driver_interface
   {
   int (*open)(char *filename, char *mode);
   int (*read)(char *buffer, int count);
   int (*write)(char *buffer, int count);
   ....
   int (*close)(void);
   };

my_device_open(char *filename, char *mode);
my_device_read(char *buffer, int count);
struct s_device_driver_interface
   my_device = {my_device_open, my_device_read, ...);

install_device_driver("MY_DEVICE", &my_device);

The third major place function pointers are used are in window programming. Both Microsoft Windows and X-Window have callback functions, though their granularity differs. When an event, such as a mouse-click, occurs when the mouse cursor is in your window, the window system calls the function whose address you have passed. This is termed a callback function since the system will literally call back to your function. The system passes along some information as to what event occurred and additional details on some of the events. In a sense, your program is made of functions which respond to the user input, rather than the more traditional procedural approach.

One major difference between the systems is how many callback functions are used. Microsoft Windows has a single callback per window (parent, child, or dialog box). Under X-Window, you can specify a callback for every object on the screen (pushbutton, radio button, etc.). The latter may be easier to comprehend, as it eliminates a large number of events being passed to a single callback. For those interested in the full treatment, you can read the thousands of manual pages on both Microsoft Windows and X-Window.