НА ГЛАВНУЮ
Меню сайта
Категория
Ghost++ [1]
С++ [55]
Развлечение
ON - LINE
Опрос
Что лучше?
Результаты | Архив опросов
Всего ответов: 327
Оbserver Ward
Онлайн всего: 1
Гостей: 1
Пользователей: 0

Друзья сайта
Заведи себе Бота
Hаша кнопка
Для обмена банерами , наша кнопка для размещения у вас на сайте

Клансайт USSR
Главная » Статьи » Программирование » С++
7. Функции (3)
7.9. Указатели на функции

Предположим, что нам нужно написать функцию сортировки, вызов которой выглядит так:

sort( start, end, compare );

где start и end являются указателями на элементы массива строк. Функция sort() сортирует элементы между start и end, а аргумент compare задает операцию сравнения двух строк этого массива.

Какую реализацию выбрать для compare? Мы можем сортировать строки лексикографически, т.е. в том порядке, в котором слова располагаются в словаре, или по длине – более короткие идут раньше более длинных. Нам нужен механизм для задания альтернативных операций сравнения. (Заметим, что в главе 12 описан алгоритм sort() и другие обобщенные алгоритмы из стандартной библиотеки С++. В этом разделе мы покажем свою собственную версию sort() как пример употребления указателей на функции. Наша функция будет упрощенным вариантом стандартного алгоритма.)

Один из способов удовлетворить наши потребности – использовать в качестве третьего аргумента compare указатель на функцию, применяемую для сравнения.
Для того чтобы упростить использование функции sort(), не жертвуя гибкостью, можно задать операцию сравнению по умолчанию, подходящую для большинства случаев. Предположим, что чаще всего нам требуется лексикографическая сортировка, поэтому в качестве такой операции возьмем функцию compare() для строк (эта функция впервые встретилась в разделе 6.10).
7.9.1. Тип указателя на функцию

Как объявить указатель на функцию? Как выглядит формальный параметр, когда фактическим аргументом является такой указатель? Вот определение функции lexicoCompare(), которая сравнивает две строки лексикографически:

#include <string>
int lexicoCompare( const string &sl, const string &s2 ) {
   return sl.compare(s2);
}

Если все символы строк s1 и s2 равны, lexicoCompare() вернет 0, в противном случае – отрицательное число, если s1 меньше чем s2, и положительное, если s1 больше s2.
Имя функции не входит в ее сигнатуру – она определяется только типом возвращаемого значения и списком параметров. Указатель на lexicoCompare() должен адресовать функцию с той же сигнатурой. Попробуем написать так:

int *pf( const string &, const string & ) ;
// нет, не совсем так

Эта инструкция почти правильна. Проблема в том, что компилятор интерпретирует ее как объявление функции с именем pf, которая возвращает указатель типа int*. Список параметров правилен, но тип возвращаемого значения не тот. Оператор разыменования (*) ассоциируется с данным типом (int в нашем случае), а не с pf. Чтобы исправить положение, нужно использовать скобки:

int (*pf)( const string &, const string & ) ;
// правильно

pf объявлен как указатель на функцию с двумя параметрами, возвращающую значение типа int, т.е. такую, как lexicoCompare().
pf способен адресовать и приведенную ниже функцию, поскольку ее сигнатура совпадает с типом lexicoCompare():

int sizeCompare( const string &sl, const string &s2 );

Функции calc() и gcd()другого типа, поэтому pf не может указывать на них:

int calc( int , int );
int gcd( int , int );

Указатель, который адресует эти две функции, определяется так:

int (*pfi)( int, int );

Многоточие является частью сигнатуры функции. Если у двух функций списки параметров отличаются только тем, что в конце одного из них стоит многоточие, то считается, что функции различны. Таковы же и типы указателей.

int printf( const char*, ... );
int strlen( const char* );

int (*pfce)( const char*, ... ); // может указывать на printf()
int (*pfc)( const char* ); // может указывать на strlen()

Типов функций столько, сколько комбинаций типов возвращаемых значений и списков параметров.
7.9.2. Инициализация и присваивание

Вспомним, что имя массива без указания индекса элемента интерпретируется как адрес первого элемента. Аналогично имя функции без следующих за ним скобок интерпретируется как указатель на функцию. Например, при вычислении выражения

lexicoCompare;

получается указатель типа

int (*)( const string &, const string & );

Применение оператора взятия адреса к имени функции также дает указатель того же типа, например lexicoCompare и &lexicoCompare. Указатель на функцию инициализируется следующим образом:

int (*pfi)( const string &, const string & ) = lexicoCompare;
int (*pfi2)( const string &, const string & ) = &lexicoCompare;

Ему можно присвоить значение:

pfi = lexicoCompare;
pfi2 = pfi;

Инициализация и присваивание корректны только тогда, когда список параметров и тип значения, которое возвращает функция, адресованная указателем в левой части операции присваивания, в точности соответствуют списку параметров и типу значения, возвращаемого функцией или указателем в правой части. В противном случае выдается сообщение об ошибке компиляции. Никаких неявных преобразований типов для указателей на функции не производится. Например:

int calc( int, int );
int (*pfi2s)( const string &, const string & ) = 0;
int (*pfi2i)( int, int ) = 0;
int main() {
   pfi2i = calc; // правильно
   pri2s = calc; // ошибка: несовпадение типов
   pfi2s = pfi2i; // ошибка: несовпадение типов
   return 0;
}

Такой указатель можно инициализировать нулем или присвоить ему нулевое значение, в этом случае он не адресует функцию.
7.9.3. Вызов

Указатель на функцию применяется для вызова функции, которую он адресует. Включать оператор разыменования при этом необязательно. И прямой вызов функции по имени, и косвенный вызов по указателю записываются одинаково:

#include

int min( int*, int );
int (*pf)( int*, int ) = min;

const int iaSize = 5;
int ia[ iaSize ] = { 7, 4, 9, 2, 5 };

int main() {
    cout << "Прямой вызов: min: "
         << min( ia, iaSize ) << endl;

    cout << "Косвенный вызов: min: "
         << pf( ia, iaSize ) << endl;

    return 0;
}

int min( int* ia, int sz ) {
    int minVal = ia[ 0 ];
    for ( int ix = 1; ix < sz; ++ix )
        if ( minVal > ia[ ix ] )
            minVal = ia[ ix ];
    return minVal;
}

Вызов

pf( ia, iaSize );

может быть записан также и с использованием явного синтаксиса указателя:

(*pf)( ia, iaSize );

Результат в обоих случаях одинаковый, но вторая форма говорит читателю, что вызов осуществляется через указатель на функцию.
Конечно, если такой указатель имеет нулевое значение, то любая форма вызова приведет к ошибке во время выполнения. Использовать можно только те указатели, которые адресуют какую-либо функцию или были проинициализированы таким значением.
7.9.4. Массивы указателей на функции

Можно объявить массив указателей на функции. Например:

int (*testCases[10])();

testCases – это массив из десяти элементов, каждый из которых является указателем на функцию, возвращающую значение типа int и не имеющую параметров.
Подобные объявления трудно читать, поскольку не сразу видно, с какой частью ассоциируется тип функции.
В этом случае помогает использование имен, определенных с помощью директивы typedef:

// typedef делает объявление более понятным
typedef int (*PFV)(); // typedef для указателя на функцию
PFV testCases[10];

Данное объявление эквивалентно предыдущему.
Вызов функций, адресуемых элементами массива testCases, выглядит следующим образом:

const int size = 10;
PFV testCases[size];
int testResults[size];

void runtests() {
    for ( int i = 0; i < size; ++i )
        // вызов через элемент массива
        testResults[ i ] = testCases[ i ]();
}

Массив указателей на функции может быть инициализирован списком, каждый элемент которого является функцией. Например:

int lexicoCompare( const string &, const string & );
int sizeCompare( const string &, const string & );

typedef int ( *PFI2S )( const string &, const string & );
PFI2S compareFuncs[2] =
  {
    lexicoCompare,
    sizeCompare
  };

Можно объявить и указатель на compareFuncs, его типом будет "указатель на массив указателей на функции”:

PFI2S (*pfCompare)[2] = compareFuncs;

Это объявление раскладывается на составные части следующим образом:

(*pfCompare)

Оператор разыменования говорит, что pfCompare является указателем. [2] сообщает о количестве элементов массива:

(*pfCompare) [2]

PFI2S – имя, определенное с помощью директивы typedef, называет тип элементов. Это "указатель на функцию, возвращающую int и имеющую два параметра типа const string &”. Тип элемента массива тот же, что и выражения &lexicoCompare.
Такой тип имеет и первый элемент массива compareFuncs, который может быть получен с помощью любого из выражений:

compareFunc[ 0 ];
(*pfCompare)[ 0 ];

Чтобы вызвать функцию lexicoCompare через pfCompare, нужно написать одну из следующих инструкций:

// эквивалентные вызовы
pfCompare [ 0 ]( string1, string2 ); // сокращенная форма
((*pfCompare)[ 0 ])( string1, string2 ); // явная форма

7.9.5. Параметры и тип возврата

Вернемся к задаче, сформулированной в начале данного раздела. Как использовать указатели на функции для сортировки элементов? Мы можем передать в алгоритм сортировки указатель на функцию, которая выполняет сравнение:

int sort( string*, string*,
int (*)( const string &, const string & ) );

И в этом случае директива typedef помогает сделать объявление sort() более понятным:

// Использование директивы typedef делает
// объявление sort() более понятным
typedef int ( *PFI2S )( const string &, const string & );
int sort( string*, string*, PFI2S );

Поскольку в большинстве случаев употребляется функция lexicoCompare, можно использовать значение параметра по умолчанию:

// значение по умолчанию для третьего параметра
int lexicoCompare( const string &, const string & );
int sort( string*, string*, PFI2S = lexicoCompare );

Определение sort() выглядит следующим образом:

1 void sort( string *sl, string *s2,
2            PFI2S compare = lexicoCompare )
3 {
4     // условие окончания рекурсии
5     if ( si < s2 ) {
6         string elem = *s1;
7         string *1ow = s1;
8         string *high = s2 + 1;
9
10        for (;;) {
11            while ( compare ( *++1ow, elem ) < 0 && low < s2) ;
12            while ( compare( elem, *--high ) < 0 && high > s1)
14            if ( low < high )
15                1ow->swap(*high);
16            else break;
17        } // end, for(;;)
18
19        s1->swap(*high);
20        sort( s1, high - 1 );
21        sort( high +1, s2 );
22    } // end, if ( si < s2 )
23 }

sort() реализует алгоритм быстрой сортировки Хоара (C.A.R.Hoare). Рассмотрим ее определение детально. Она сортирует элементы массива от s1 до s2. Это рекурсивная функция, которая вызывает сама себя для последовательно уменьшающихся подмассивов. Рекурсия окончится тогда, когда s1 и s2 укажут на один и тот же элемент или s1 будет располагаться после s2 (строка 5).

elem (строка 6) является разделяющим элементом. Все элементы, меньшие чем elem, перемещаются влево от него, а большие – вправо. Теперь массив разбит на две части. sort() рекурсивно вызывается для каждой из них (строки 20-21).
Цикл for(;;) проводит разделение (строки 10-17). На каждой итерации цикла индекс low увеличивается до первого элемента, большего или равного elem (строка 11). Аналогично high уменьшается до последнего элемента, меньшего или равного elem (строка 12). Когда low становится равным или большим high, мы выходим из цикла, в противном случае нужно поменять местами значения элементов и начать новую итерацию (строки 14-16). Хотя элементы разделены, elem все еще остается первым в массиве. swap() в строке 19 ставит его на место до рекурсивного вызова sort() для двух частей массива.
Сравнение производится вызовом функции, на которую указывает compare (строки 11-12). Чтобы поменять элементы массива местами, используется операция swap() с аргументами типа string, представленная в разделе 6.11.
Вот как выглядит main(), в которой применяется наша функция сортировки:

#include < iostream>
#include < string>

// это должно бы находиться в заголовочном файле
int lexicoCompare( const string &, const string & );
int sizeCompare( const string &, const string & );
typedef int (*PFI)( const string &, const string & );
void sort( string *, string *, PFI=lexicoCompare );

string as[10] = { "a", "light", "drizzle", "was", "falling",
                  "when", "they", "left", "the", "museum" };

int main() {
    // вызов sort() с значением по умолчанию параметра compare
    sort( as, as + sizeof(as)/sizeof(as[0]) - 1 );

   // выводим результат сортировки
   for ( int i = 0; i < sizeof(as)/sizeof(as[0]); ++i )
       cout << as[ i ].c_str() << "\n\t";
}

Результат работы программы:

"a"
"drizzle"
"falling"
"left"
"light"
"museum"
"the"
"they"
"was"
"when"

Параметр функции автоматически приводится к типу указателя на функцию:

// typedef представляет собой тип функции
typedef int functype( const string &, const string & );
void sort( string *, string *, functype );

sort() рассматривается компилятором как объявленная в виде

void sort( string *, string *,
int (*)( const string &, const string & ) );

Два этих объявления sort() эквивалентны.
Заметим, что, помимо использования в качестве параметра, указатель на функцию может быть еще и типом возвращаемого значения. Например:

int (*ff( int ))( int*, int );
ff() объявляется как функция, имеющая один параметр типа int и возвращающая    указатель на функцию типа
int (*)( int*, int );

И здесь использование директивы typedef делает объявление понятнее. Объявив PF с помощью typedef, мы видим, что ff() возвращает указатель на функцию:

// Использование директивы typedef делает
// объявления более понятными
typedef int (*PF)( int*, int );
PF ff( int );

Типом возвращаемого значения функции не может быть тип функции. В этом случае выдается ошибка компиляции. Например, нельзя объявить ff() таким образом:

// typedef представляет собой тип функции
typedef int func( int*, int );

func ff( int ); // ошибка: тип возврата ff() - функция
7.9.6. Указатели на функции, объявленные как extern "C"

Можно объявлять указатели на функции, написанные на других языках программирования. Это делается с помощью директивы связывания. Например, указатель pf ссылается на С-функцию:

extern "C" void (*pf)(int);
Через pf вызывается функция, написанная на языке С.
extern "C" void exit(int);
// pf ссылается на C-функцию exit()
extern "C" void (*pf)(int) = exit;
int main() {
  // ...
  // вызов С-функции, а именно exit()
  (*pf)(99);
}

Вспомним, что присваивание и инициализация указателя на функцию возможны лишь тогда, когда тип в левой части оператора присваивания в точности соответствует типу в правой его части. Следовательно, указатель на С-функцию не может адресовать функцию С++ (и инициализация его таким адресом не допускается), и наоборот. Подобная попытка вызывает ошибку компиляции:

void (*pfl)(int);
extern "C" void (*pf2)(int);
int main() {
   pfl = pf2; // ошибка: pfl и pf2 имеют разные типы
   // ...
}

Отметим, что в некоторых реализациях С++ характеристики указателей на функции С и С++ одинаковы. Отдельные компиляторы могут допустить подобное присваивание, рассматривая это как расширение языка.
Если директива связывания применяется к объявлению, она затрагивает все функции, участвующие в данном объявлении.
В следующем примере параметр pfParm также служит указателем на С-функцию. Директива связывания применяется к объявлению функции, к которой этот параметр относится:

// pfParm - указатель на С-функцию
extern "C" void f1( void(*pfParm)(int) );

Следовательно, f1() является С-функцией с одним параметром – указателем на С-функцию. Значит, передаваемый ей аргумент должен быть либо такой же функцией, либо указателем на нее, поскольку считается, что указатели на функции, написанные на разных языках, имеют разные типы. (Снова заметим, что в тех реализациях С++, где указатели на функции С и С++ имеют одинаковые характеристики, компилятор может поддерживать расширение языка, позволяющее не различать эти два типа указателей.)
Коль скоро директива связывания относится ко всем функциям в объявлении, то как же объявить функцию С++, имеющую в качестве параметра указатель на С-функцию? С помощью директивы typedef. Например:

// FC представляет собой тип:
// С-функция с параметром типа int, не возвращающая никакого значения
extern "C" typedef void FC( int );

// f2() - C++ функция с параметром -
// указателем на С-функцию
void f2( FC *pfParm );

Упражнение 7.21

В разделе 7.5 приводится определение функции factorial(). Напишите объявление указателя на нее. Вызовите функцию через этот указатель для вычисления факториала 11.
Упражнение 7.22

Каковы типы следующих объявлений:

(a) int (*mpf)(vector<int>&);
(b) void (*apf[20])(doub1e);
(c) void (*(*papf)[2])(int);

Как сделать эти объявления более понятными, используя директивы typedef?
Упражнение 7.23

Вот функции из библиотеки С, определенные в заголовочном файле <cmath>:

double abs(double);
double sin(double);
double cos(double);
double sqrt(double);

Как бы вы объявили массив указателей на С-функции и инициализировали его этими четырьмя функциями? Напишите main(), которая вызывает sqrt() с аргументом 97.9 через элемент массива.
Упражнение 7.24

Вернемся к примеру sort(). Напишите определение функции
int sizeCompare( const string &, const string & );
Если передаваемые в качестве параметров строки имеют одинаковую длину, то sizeCompare() возвращает 0; если первая строка короче второй, то отрицательное число, а если длиннее, то положительное. Напоминаем, что длина строки возвращается операцией size() класса string. Измените main() для вызова sort(), передав в качестве третьего аргумента указатель на sizeCompare().
Категория: С++ | Добавил: r2d2 (29.09.2011)
Просмотров: 1268 | Рейтинг: 0.0/0
Всего комментариев: 0
Добавлять комментарии могут только зарегистрированные пользователи.
[ Регистрация | Вход ]
Born in Ussr
Залогиниться
Главная Регистрация Вход
Турниры

/j clan ussr /j clan cccp