Devolver un puntero de función desde una función en C/C++

En C/C++, como punteros de datos normales (int *, char *, etc.), puede haber punteros a funciones. Cada función creada en un programa obtiene una dirección en la memoria, ya que los punteros se pueden usar en C / C++ , por lo que también se puede crear un puntero a una función.

Sintaxis:

tipo de retorno (*function_pointer_name) (argument_type_1, argument_type_2, ……, argument_type_n) = &function_name;

O

tipo de retorno (*function_pointer_name) (argument_type_1, argument_type_2, ……, argument_type_n) = function_name;

NOTA: El tipo de argumentos y el tipo de retorno del puntero de función deben coincidir con la función real presente en el programa.

Programa 1:

// C program for the above approach
#include <stdio.h>
 
// Function to add the value 10 to
// the variable a
void demo(int* a) { *a += 10; }
 
// Driver Code
int main()
{
    int num = 20;
 
    // ptr contains address of demo
    // function or void
    void (*ptr)(int*) = &demo;
 
    // or (*ptr)(&num);
    ptr(&num);
 
    printf("%d", num);
 
    return 0;
}

// C++ program for the above approach
#include <iostream>
using namespace std;
 
void demo(int& a)
{
    a += 10;
}
 
// Driver Code
int main()
{
    int num = 20;
 
    // Now ptr contains address of demo
    // function or void
    void (*ptr)(int*) = &demo;
 
    // or (*ptr)(num);
    ptr(num);
 
    cout << num << endl;
 
    return 0;
}

30

Devolver puntero de función de función: para devolver un puntero de función de una función, el tipo de retorno de función debe ser un puntero a otra función. Pero el compilador no acepta ese tipo de devolución para una función, por lo que debemos definir un tipo que represente ese puntero de función en particular.

Sintaxis:

typedef tipo de retorno (*function_pointer_name) (argument_type_1, argument_type_2, ……, argument_type_n);

Esto crea un tipo que representa un puntero para una función particular.

Programa 2:

// C program for the above approach
#include <stdio.h>
typedef int (*ptr)(int*);
typedef ptr (*pm)();
 
int fun1(int* y)
{
    printf("geeks!!\n");
    return *y + 10;
}
 
// Function that return type ptr
ptr fun()
{
    printf("Hello ");
 
    // or return fun1;
    /* or
     int(*pt)(int*)=fun1;
     return pt
  */
    return &fun1;
}
 
// Driver Code
int main()
{
    int a = 10;
 
    pm u = fun;
 
    printf("%d", (*u())(&a));
 
    return 0;
}

// C++ program for the above approach
#include <iostream>
using namespace std;
typedef int (*ptr)(int*);
typedef ptr (*pm)();
 
int fun1(int* y)
{
    cout << "geeks!!" << endl;
    return *y + 10;
}
 
// Function that returns the type ptr
ptr fun()
{
    cout << "Hello ";
    return &fun1;
}
 
// Driver Code
int main()
{
    int a = 10;
    pm u = fun;
    cout << (*u())(&a) << endl;
 
    return 0;
}

Hello geeks!!
20

Declarar una array que tiene dos punteros de función en cuanto a sus elementos y estos punteros de función, a su vez, devuelven otros punteros de función que apuntan a otras funciones. La lógica de la función main() del código del controlador se puede cambiar en el programa anterior como:

Programa 3:

// C program for the above approach
#include <stdio.h>
 
// This defines a type for
// function prototypes
typedef int (*ptr)(int*);
typedef ptr (*pm)();
 
int fun1(int* y)
{
    printf("geeks!!\n");
    return *y + 10;
}
 
// fun() is a function with
// return type ptr
ptr fun()
{
    printf("Hello ");
 
    // or return fun1;
    /* or
     int(*pt)(int*)=fun1;
     return pt
  */
    return &fun1;
}
 
// Driver code
int main()
{
    int a = 10;
    pm u = fun;
 
    /*
    Above line assigns 'u' which is
    of type 'pm' to an array of size
    1 which has function pointers as
    its elements and these function
    pointers in turn return other
    function pointer which points to
    other functions.
 
    Now this 'p' array contains a function
    pointer 'u' which points to fun() and
    this fun() returns another function
    pointer which points to fun1().
  */
    int (*(*p[1])())(int*) = { u };
 
    printf("%d", (*p[0]())(&a));
}

// C++ program for the above approach
#include <iostream>
using namespace std;
 
// This defines a type for
// function prototypes
typedef void (*ptr)(int&);
typedef ptr (*pm)();
 
void fun1(int& z)
{
    printf("geeks!!\n");
    cout << z + 10 << endl;
}
 
// Function that returns type ptr
ptr fun()
{
    printf("Hello ");
 
    // or return fun1;
    /* or
     int(*pt)(int*)=fun1;
     return pt
  */
    return &fun1;
}
 
// Driver Code
int main()
{
    int a = 10;
    pm u = fun;
 
    /*
    Above line assigns 'u' which is
    of type 'pm' to an array of size
    1 which has function pointers as its
    elements and these function pointers
    in turn return other function pointer
    which points to other functions.
 
    Now this 'p' array contains a function
    pointer 'u' which points to fun() and
    this fun() returns another function
    pointer which points to fun1() and
    this fun1() returns void.
  */
    void (*(*p[1])())(int&) = { u };
 
    (*p[0]())(a);
}

Hello geeks!!
20