Funciones y punteros de función

En conclusión

Para una función definida, el nombre de la función, la dirección de la función y el puntero de la función apuntan a la dirección de entrada de la función.

probar

Primero defina las siguientes funciones:

/**********************************************************
* 函数：FuncPointer
* 描述：证明函数指针与函数名关系
* 参数：无
* 返回：无
* 备注：
**********************************************************/
void FuncPointer(void)
{
    
    
	cout << "调用FuncPointer函数" << endl;
	cout << FuncPointer << endl;//输出函数名
	cout << &FuncPointer << endl;//输出函数地址
	cout << *&FuncPointer << endl;//输出函数地址指向对象
}

En la función principal:

int main()
{
    
    
    FuncPointer();//函数名调用
    (&FuncPointer)();//地址方式调用
    (*&FuncPointer)();//间址方式调用（函数地址指向对象）
 }

Resultado de la ejecución:

se puede ver que el valor del nombre de la función, el puntero de la función y el puntero de la función al objeto son iguales y apuntan al mismo valor de dirección de entrada. La función se puede llamar a través de estos tres métodos.

Uso de punteros de función

De lo anterior se puede ver que una función se puede llamar en la forma de un puntero de función, por lo que si el valor de la dirección de la función se asigna a una variable de puntero, la función se puede llamar a través de esta variable de puntero. Entonces la pregunta es, ¿cómo se define el tipo de este puntero? Para asignar la dirección de función a esta variable de puntero, el tipo asociado con la variable de puntero debe ser el mismo que el tipo asociado con el puntero de función. Entonces, primero debemos entender el tipo de función.

Tipo de función

1. Definición de función: tipo nombre de función (tabla de parámetros formales); la función se compone de tres partes: (1) tipo es el valor de retorno tipo de la función, (2) nombre de función es la entrada de dirección de la función que llama, (3) formal La tabla de parámetros se pasa a la función Parámetros externos requeridos. Cuando (1) y (3) de dos funciones son iguales, llamamos a estas dos funciones el mismo tipo de función. Las siguientes dos funciones f1 y f2 son funciones del mismo tipo.

float f1(float x)
{
    
    
	return (4 / (1 + x * x));
}

float f2(float x)
{
    
    
	return ((float)sqrt(1 + pow(x, 2)));
}

2. Utilice typedef para definir el tipo de función: typedef type nombre del tipo de función (lista de parámetros de función)

typedef float IntegralFunction(float x);

3. Utilice tipos de función definidos para declarar funciones o definir variables

IntegralFunction f1, f2;//声明f1,f2

4. Definición de puntero de función
   (1) tipo de función * nombre de variable de puntero;
   (2) tipo (* nombre de variable de puntero) (lista de parámetros formales);
   por ejemplo, use el tipo de función definido anteriormente para declarar un puntero de función:
   (1) IntegralFunction * p ;
   (2)) Float (* p) (float);
   Cuando se usa (2) para definir una variable de puntero, debe tenerse en cuenta que los paréntesis en ambos lados de * p no pueden ser menores. Si faltan los paréntesis, se convierte en float * p (float), y p se convierte en un tipo de retorno Es una función de int *.

El uso de punteros de función:

float f1(float x)
{
    
    
	return (4 / (1 + x * x));
}

float f2(float x)
{
    
    
	return ((float)sqrt(1 + pow(x, 2)));
}
/**********************************************************
* 函数：ComputeIntegral
* 描述：求定积分
* 参数：*func - 原函数地址
		a - 积分下限
		b - 积分上限
* 返回：积分结果
* 备注：
**********************************************************/
float ComputeIntegral(IntegralFunction *func, float a, float b)
{
    
    
	const int EdValue = 1000;
	int n = (int)((float)EdValue * (b - a));

	int i;
	float Tn,h;

	h = (b - a) / n;
	Tn = (h * (func(a) + func(b))) / 2;

	for (i = 1; i < n; i++)
	{
    
    
		Tn += h * func(a + i * h);
	}

	return Tn;
}

/**************求函数积分***************/
typedef float IntegralFunction(float x);
IntegralFunction f1, f2;//声明f1,f2
float ComputeIntegral(IntegralFunction* func, float a, float b);

La función ComputeIntegral calcula el tamaño de la integral definida. El puntero de función pasada * func es conveniente para que se pasen diferentes funciones del mismo tipo. Para calcular la integral definida de diferentes funciones, solo necesita modificar el en el puntero de función. Llame a la función ComputeIntegral de la siguiente manera para calcular el tamaño integral definido de f1 en 0-1.

int main()
{
    
    
    float a,b,result;
    cout << "计算定积分" << endl;
    cout << "输入积分下限" << endl;
    cin >> a ;
    cout << "输入积分上限" << endl;
    cin >> b ;
    result = ComputeIntegral(f1,a,b);
    cout << "定积分的值:" << result << endl;
 }

Resultado de la operación:

con el puntero de función, la dirección de la función se puede pasar a otras funciones como un parámetro de función. Esta función puede llamar a la función pasada a través del puntero de función pasada para lograr una función específica.