• Ponteiros de Função

Um ponteiro para uma função contém o endereço da função na memória. De modo semelhante a um array, um nome de função é realmente o endereço na memória do começo do código que executa a tarefa da função.Ponteiros de funções podem ser passados para função, retornados por funções, armazenados em arrays e atribuídos a outros ponteiros de funções.

Um ponteiro de função é atribuido da seguinte forma.

tipo (*) ( tipos )

bool (*) ( int )
int (*)( double, int )

Confira um exemplo prático facil de entender:

#include <iostream>
using std::cout;
using std::cin;
using std::endl;

int aritmetica( int (*)( int ), int );
int soma ( int );
int sub ( int );

int main()
{
   int numero;

   cout << "Digite um numero: " << endl;
   cin >> numero;

   cout << aritmetica( soma, numero ) << endl;
   cout << aritmetica( sub, numero ) << endl;

   cin;
   return 0;
}

int aritmetica ( int (*ponteiro)( int ), int numeros )
{
   return ponteiro( numeros );
}

int soma( int numero )
{
   return numero + 1;
}

int sub ( int numero )
{
   return numero - 1;
}

Observe um exemplo mais complexo utilizando o bubble sort

#include <iostream>
using std::cout;
using std::cin;
using std::endl;

#include <iomanip>

using std::setw;

void bolha ( int [], const int, bool (*)( int, int) );
bool crescente ( int, int );
bool decrescente ( int, int );

int main()
{
   const int a_tamanho = 11;
   int ordem,
       contador,
       a[ a_tamanho ] = { 2, 1, 3, 4, 7, 10, 12, 89, 68, 42, 37 };

   cout << "Digite 1 para ordem crescente \n"
           << "Ditite 2 para ordem decrescente: ";
   cin >> ordem;

   if ( ordem == 1 )
   {
      bolha ( a, a_tamanho, crescente );
      cout << "Dados na ordem crescente " << endl;
   }
   else
   {
      bolha ( a, a_tamanho, decrescente );
      cout << "Dados na ordem decrescente " << endl;
   }

   for ( contador = 0; contador < a_tamanho; contador++ )
      cout << setw( 4 ) << a[ contador ];

   cout << endl;

   cin;
   return 0;
}

void bolha ( int b[], const int b_tamanho, bool (*comparar)( int, int ) )
{
   void ordenar ( int * const, int * const );     // prototipo *

   for ( int i = 1; i < b_tamanho; i++ )
   {
      for ( int contador = 0; contador < b_tamanho - 1; contador++ )
      {
         if ( (*comparar) ( b[ contador ], b[ contador + 1 ] ) )
         {
            ordenar( &b[ contador ], &b[ contador + 1 ] );
         }
      }
    }
}

void ordenar ( int * const elemento1, int * const elemento2 )
{
   int temp;

   temp = *elemento1;
   *elemento1 = *elemento2;
   *elemento2 = temp;
}

bool crescente ( int a, int b )
{
   return b < a;    // troca se b eh menor que a
}

bool decrescente ( int a, int b )
{
   return b > a;
}

Caso o usuario aperte 1. um ponteiro da função crescente é enviado para a função bolha.
Caso o usuario aperte 2. um ponteiro da função decrescente é enviado para a função bolha.

Cuidado, a linha de prototipo, ordenar, que esta dentro da função bolha, é necessario para que bolha possa usar a função ordenar.

Ponteiros de funções são muito interessantes. Podemos usar por exemplo, um array de ponteiros para executar 2 tipos de funções diferentes.

Observe

#include <iostream>

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

void funcao1 ( int );
void funcao2 ( int );

int main()
{
  void (*f[2])( int ) = { funcao1, funcao2 };
  int escolha;

  cout << "Escolha entre 0 e 1 ";
  cin >> escolha;

  ( *f[ escolha ] ) ( escolha ); // execução

  cin;
  return 0;
}

void funcao1( int a )
{
  cout << "Funcao 1" << endl;
  cout << "vc escolheu a funcao "<< a << endl;
}

void funcao2( int a )
{
  cout << "Funcao 2" << endl;
  cout << "vc escolheu a funcao "<< a << endl;
}

Legal e interessante!!!

Perguntas??? Email