Объяснение указателей функций

Ответ 1

Ну, это немного запутывает.

Тип функции и указатель на тип функции действительно два разных типа (не более, чем int и указатель на int). Однако существует правило, что тип функции распадается на указатель на тип функции почти во всех контекстах. Здесь разлагающееся свободно означает преобразованное (существует разница между преобразованием типов и распадом, но вы, вероятно, сейчас не заинтересованы в нем).

Важно то, что почти каждый раз, когда вы используете тип функции, вы получаете указатель на тип функции. Обратите внимание, что почти, однако, почти каждый раз не всегда!

И вы попадаете в некоторые случаи, когда этого не происходит.

typedef void(functionPtr)(int);
functionPtr fun = function;

Этот код пытается скопировать одну функцию (а не указатель! function!) в другую. Но, конечно, это невозможно - вы не можете копировать функции на С++. Компилятор не допускает этого, и я не могу поверить, что вы его скомпилировали (вы говорите, что у вас есть ошибки компоновщика?)

Теперь этот код:

typedef void(functionPtr)(int);
functionPtr function;
function(5);

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

Ответ 2

Самый интересный из ваших примеров - этот, воспроизведенный здесь без использования typedef:

void function(int a) { // declaration and definition of 'function'
    std::cout << a << std::endl;
}

int main() {
    void function(int); // declaration of 'function'
    function(5);
}

В большинстве контекстов на С++ повторное объявление function в локальной области будет затенять глобальный ::function. Поэтому, ожидая ошибки компоновщика, имеет смысл - main()::function не имеет права определения?

Кроме того, специальные функции в этом отношении. Из примечания в [basic.scope.pdel]:

Объявление функций в области блока и объявления переменных с указателем extern в области блока ссылаются на объявления, которые являются членами охватывающее пространство имен, но они не вводят новые имена в эту область.

Итак, пример кода в точности эквивалентен:

void function(int a) { /* ... */ }
void function(int ); // just redeclaring it again, which is ok

int main() {
    function(5);
}

Вы также можете проверить это, поместив глобальный function в некоторое пространство имен, N. На этом этапе локальная декларация области добавит имя в ::, но у нее не будет определения - значит, вы получите ошибку компоновщика.

Другая интересная вещь, которую вы затронули, - это понятие преобразования функции в указатель, [conv.func]:

Значение l типа функции T может быть преобразовано в prvalue типа "указатель на T". Результатом является указатель на функция.

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

fun(5);         // OK, call function pointed to by 'fun'
(*fun)(5);      // OK, first convert *fun back to 'fun'
function(5);    // OK, first convert to pointer to 'function'
(*function)(5); // OK, unary* makes function get converted to a pointer
                // which then gets dereferenced back to function-type
                // which then gets converted back to a pointer

Ответ 3

Посмотрите свои примеры один за другим и что они на самом деле означают.

typedef void(functionPtr)(int);

void function(int a){
    std::cout << a << std::endl;
}

int main() {

    functionPtr fun = function;
    fun(5);

    return 0;
}

Здесь вы создаете typedef functionPtr для функций, которые принимают и int, и не возвращают значения. functionPtr на самом деле не является typedef для указателя функции, а фактической функции.

Затем вы пытаетесь объявить новую функцию fun и назначьте ей function. К сожалению, вы не можете назначать функции, поэтому это не работает.

int main() {

    functionPtr fun;
    fun(5);

    return 0;
}

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

typedef void(functionPtr)(int);

void function(int a){
    std::cout << a << std::endl;
}

int main() {

    functionPtr function;
    function(5);

    return 0;
}

Что здесь происходит? Вы определяете typedef, а в основном пишете functionPtr function;. Это в основном просто прототип для функции, которую вы уже написали, function. Он повторяет, что эта функция существует, но в противном случае она ничего не делает. Фактически вы можете написать:

typedef void(functionPtr)(int);

void function(int a){
    std::cout << a << std::endl;
}

int main() {

    functionPtr function;
    functionPtr function;
    functionPtr function;
    void function(int);

    function(5);

    return 0;
}

Сколько раз вы хотите, это ничего не изменит. function(5), который вы вызываете, всегда одно и то же.

Одна вещь, которую вы можете сделать на С++, - объявить прототип функции с помощью такого типа typedef, но вы не можете определить ее таким образом.

typedef void(*functionPtr)(int);

functionPtr function(int a){
    std::cout << a << std::endl;
}

Здесь вы определяете функцию, которая возвращает указатель на функцию, но затем вы ее не возвращаете. Компилятор, в зависимости от ваших настроек, может жаловаться или не жаловаться. Но снова function полностью отделен от functionPtr. Вы по существу записали

void (*)(int)   function(int a) {
    ...
}

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

Ответ 4

typedef void functionPtr (int);

void function (int a){
    std::cout << a << std::endl;
}

int main() {

    functionPtr *func;
    func = function;
    func(5);
    return 0;
}

Вы можете использовать его таким образом, я проверил. В этом вопросе действительно сложный вопрос.