c++ - una - tipos de funciones en c




¿Cuál es la diferencia entre las funciones de llamada de la siguiente manera? (4)

foo();

(*foo)();

(&foo)();

¿Cuál es exactamente la diferencia entre estas llamadas de función (asumiendo que foo() está definido en algún lugar)? ¿Y hay situaciones en las que uno podría ser usado sobre otro?

Además, ¿por qué no funcionan &foo() y *foo() ?


Dado que está etiquetado como c++ , es posible que una función devuelva una referencia en ese idioma, y ​​tal función podría llamarse como &foo() :

#include <iostream>

using std::cout;
using std::endl;

int & foo() {
    static int f = 5;
    return f;
}

int main() {
    cout << foo() << endl;
    *(&foo()) = 7;
    cout << foo() << endl;
    return 0;
}      

No dices exactamente qué es foo , pero asumiré que es una función.

¿Cuál es exactamente la diferencia entre estas llamadas de función?

Obviamente, el primero llama a la función utilizando la sintaxis habitual.

El tercero toma la dirección de la función e intenta llamarla; el lenguaje permite llamar a los punteros de función como si fueran la función a la que apuntan, por lo que esto es equivalente a foo() .

El segundo intenta desreferenciar la función. La desreferenciación requiere un puntero, y el lenguaje permite la conversión implícita de una función a un puntero a esa función, por lo que es equivalente a (*(&foo))() , que a su vez es equivalente a foo() .

Para resumir: los tres hacen lo mismo.

¿Y hay situaciones en las que uno podría ser usado sobre otro?

A menos que desee decorar su código con jeroglíficos innecesarios, no hay razón para usar otra forma que no sea la primera forma, ya sea para funciones o punteros a funciones.

Además, ¿por qué no funcionan &foo() y *foo() ?

Las reglas de precedencia significan que estas son equivalentes a &(foo()) y *(foo()) ; es decir, llaman a la función e intentan tomar la dirección y anular el resultado. La primera forma "funcionará" si la función tiene un tipo de retorno; el segundo "funcionará" si devuelve un puntero o (en C ++) algo con un operator*() unario sobrecargado operator*() .


Si foo es un designador de función, estos son todos equivalentes en C:

foo();
(foo)();
(*foo)();
(***foo)();
(*&foo)();

foo () llama a la función foo.

void foo() {return;}
foo();

(* foo) () hace referencia a un puntero de (función) llamado foo y lo llama con cero argumentos.

void bar() {return;}

int main(int argc, char** argv){
    void(*foo)() = &bar;
    (*foo)(); // works
    (*bar)(); // also works
    return 0;
}

(& foo) () toma la referencia a una función foo y la llama con cero argumentos.

void bar() {return;}

int main(int argc, char** argv){
    (&bar)();
    return 0;
}

Espero que haya ayudado.







c