qsort_example.c

//  Пример использования функции сортировки qsort
//  Также демонстрируется ввод чисел с обработкой ошибок
#include <stdio.h>
#include <stdlib.h> //  Подключаем функцию быстрой сортировки qsort и преобразования строк в числа strtol
#include <string.h> //  strlen
#include <limits.h> //  LONG_MIN, LONG_MAX

//  Размер буфера для преобразования строки в число
#define NUMBUF_SIZE 32

//-------------------------------------------------------------------
//  Прототипы функций
//  Функиця считывает строку из файла и преобразует ее в число типа long,
//  которое записывает по указателю l
//  Возвращает 1 в случае удачи или 0 при ошибке ввода, выводит сообщения
//  об ошибках в файл stderr
int get_long( FILE* fp, long* l );
//  Функция выводит содержимое массива в стиле С
void    print_array( char* name, long* array, long array_size );
//-------------------------------------------------------------------
//  Функции сравнения элементов e1 и e2 для qsort
int cmp_long( const void *e1, const void *e2 );
//  Функции сравнения по модулю элементов e1 и e2 для qsort
int cmp_long_abs( const void *e1, const void *e2 );
//  Функции обратного сравнения элементов e1 и e2 для qsort
int cmp_long_rev( const void *e1, const void *e2 );
//-------------------------------------------------------------------

//-------------------------------------------------------------------
int main( int argc, char* argv[] )
{
    //  Указатель на первый элемент динамически выделенного массива
    long*   array;
    long    array_size;
    long    index;
    long    sort_mode = 0;
    //  Флаг ошибки
    int eflag;

    printf( "Программа демонстрирует сортировку "
            "массива при помощи qsort\n" );
    do
    {
        eflag = 0;
        printf( "Введите количество элементов в массиве: " );
        if( get_long( stdin, &array_size ) )
        {
            if( array_size <= 0 )
            {
                printf( "Количество элементов в массиве "
                    "должно быть больше нуля!\n" );

                eflag = 1;
            }
        }
        else
        {
            eflag = 1;
        }
    }
    while( eflag );

    printf( "Пытаюсь создать массив из %ld элементов... ", array_size );
    fflush( stdout );
    array = (long*)malloc( array_size * sizeof(long) );
    if( array )
    {
        printf( "УСПЕХ\n" );
        printf( "Введите элементы массива:\n" );
        index = 0;
        while( index < array_size )
        {
            printf( "array[%ld] = ", index );
            if( get_long( stdin, &array[index] ) )
            {
                index++;
            }
        }
        printf( "Содержимое массива до сортировки:\n" );
        print_array( "unsorted_array", array, array_size );

        printf( "0 - прямая сортировка\n" );
        printf( "1 - прямая сортировка по модулю\n" );
        printf( "2 - обратная сортировка\n" );
        do
        {
            eflag = 0;
            printf( "Введите режим сортировки (0 - 2): " );
            if( get_long( stdin, &sort_mode ) )
            {
                if( !((sort_mode >= 0) && (sort_mode <= 2)) )
                {
                    printf( "Неизвестный режим "
                            "сортировки!\n" );
                    eflag = 1;
                }
            }
            else
            {
                eflag = 1;
            }
        }
        while( eflag );

        //  Отсортируем массив
        switch( sort_mode )
        {
            case    0:
                printf( "Сортировка по возрастанию\n" );
                //  Функции qsort надо передать указатель
                //  на первый элемент массива, размер
                //  массива, размер одного элемента
                //  массива и указатель на функцию для
                //  сравнения элементов массива
                qsort( array, array_size,
                        sizeof(long), cmp_long );
                break;

            case    1:
                printf( "Сортировка по модулю\n" );
                qsort( array, array_size,
                        sizeof(long), cmp_long_abs );
                break;

            case    2:
                printf( "Сортировка по убыванию\n" );
                qsort( array, array_size,
                        sizeof(long), cmp_long_rev );
                break;
        }

        printf( "Содержимое массива после сортировки:\n" );
        print_array( "sorted_array", array, array_size );

        //  Не забудем освободить память
        free( array );
    }
    else
    {
        perror( "malloc" );
    }

    return  0;
}
//-------------------------------------------------------------------
int get_long( FILE* fp, long* l )
{
    int result = 0;
    char    buf[ NUMBUF_SIZE ];
    long    val;
    char*   end;
    size_t  len;

    *l = 0;
    //  Попробуем считать строку из файла
    if( fgets( buf, NUMBUF_SIZE, fp ) )
    {
        len = strlen( buf );
        if( len > 0 )
        {
            if( buf[ len-1 ] == '\n' )
            {
                len--;
                buf[ len ] = '\0';
            }
            if( len > 0 )
            {
                //  Попробуем преобразовать строку
                //  в число типа long
                val = strtol( buf, &end, 0 );
                if( *end == '\0' )
                {
                    //  Строка была успешно
                    //  преобразована в число
                    //  проверка на переполнение
                    if( val>LONG_MIN && val<LONG_MAX )
                    {
                        *l = val;
                        result++;
                    }
                    else
                    {
                        perror( "strtol" );
                    }
                }
                else
                {
                    fprintf( stderr, "Ошибка! Не удалось "
                        "преобразовать '%s' в число: "
                        "обнаружен мусор '%s'\n",
                        buf, end );
                }
            }
        }
    }
    else
    {
        perror( "fgets" );
    }

    return  result;
}
//-------------------------------------------------------------------
void    print_array( char* name, long* array, long array_size )
{
    long    index;

    printf( "%s[%ld] = { ", name, array_size );
    for( index = 0; index < array_size; index++ )
    {
        printf( "%ld", array[index] );
        if( index < array_size - 1 )
        {
            printf( ", " );
        }
        else
        {
            printf( " " );
        }
    }
    printf( "};\n" );
}
//-------------------------------------------------------------------
//  Функции сравнения элементов e1 и e2 для qsort
int cmp_long( const void *e1, const void *e2 )
{
    int result = 0;

    if( *(long*)e1 < *(long*)e2 )
    {
        result--;
    }
    else
    if( *(long*)e1 > *(long*)e2 )
    {
        result++;
    }

    return  result;
}
//-------------------------------------------------------------------
//  Функции сравнения по модулю элементов e1 и e2 для qsort
int cmp_long_abs( const void *e1, const void *e2 )
{
    int result = 0;

    if( abs(*(long*)e1) < abs(*(long*)e2) )
    {
        result--;
    }
    else
    if( abs(*(long*)e1) > abs(*(long*)e2) )
    {
        result++;
    }

    return  result;
}
//-------------------------------------------------------------------
//  Функции обратного сравнения элементов e1 и e2 для qsort
int cmp_long_rev( const void *e1, const void *e2 )
{
    int result = 0;

    if( *(long*)e1 < *(long*)e2 )
    {
        result++;
    }
    else
    if( *(long*)e1 > *(long*)e2 )
    {
        result--;
    }

    return  result;
}
//-------------------------------------------------------------------