Este documento describe cómo usar arrays de punteros a funciones para implementar código dirigido por tablas. Se definen varias funciones falsas usando un macro y se crea un array que apunta a estas funciones. Al indexar y dereferenciar el array se puede elegir qué función ejecutar. También explica cómo pasar arrays a funciones mediante punteros y muestra un ejemplo de cálculo del producto escalar de dos vectores usando una función que recibe los vectores como parámetros.

1. UNIDAD EDUCATIVA “JUAN
DE VELASCO”
INTEGRANTES:
• SATALIN CUVI
• KEVIN YUPA
TEMA:
FUNCIONES DE VECTORES
FECHA:
12-12-2017

2. Una de las construcciones más interesantes que
puede crear es un array de punteros a funciones.
Para elegir una función, sólo indexe el array y
dereferencie el puntero. Esto permite implementar el
concepto de código dirigido por tabla(table-driven
code); en lugar de usar estructuras condicionales o
sentencias case, se elige la función a ejecutar en
base a una variable (o una combinación de
variables). Este tipo de diseño puede ser útil si añade
y elimina funciones de la tabla con frecuencia (o si
quiere crear o cambiar una tabla dinámicamente).

3.  El siguiente ejemplo crea algunas funciones falsas usando una macro de
preprocesador, después crea un array de punteros a esas funciones usando
inicialización automática. Como puede ver, es fácil añadir y eliminar funciones
de la table (y por tanto, la funcionalidad del programa) cambiando una
pequeña porción
 //: C03:FunctionTable.cpp
 // Using an array of pointers to functions
 #include <iostream>
 using namespace std;
 // A macro to define dummy functions:
 #define DF(N) void N() {
 cout << "function " #N " called..." << endl; }
 DF(a); DF(b); DF(c); DF(d); DF(e); DF(f); DF(g);
 void (*func_table[])() = { a, b, c, d, e, f, g };
 int main() {
 while(1) {
 cout << "press a key from 'a' to 'g' "
 "or q to quit" << endl;
 char c, cr; cin.get(c);
 cin.get(cr); // second one for CR
 if ( c == 'q' )
 break; // ... out of while(1)
 if ( c < 'a' || c > 'g' )
 continue;
 (*func_table[c - 'a'])();
 }
 } ///:~

4.  Supongamos que queremos pasar un array a una
función. La solución es pasar punteros. El nombre
de un array es un puntero al primer elemento del
array. Así, si hemos definido int taco[10]como un
array de diez enteros, taco será un puntero al array.
Por ejemplo, sea guacamole un array de 6 enteros:
6, 63, 112, 18, -52, 16. guacamole es simplemente
un puntero al primer elemento.
Entonces, *guacamole equivale al valor 6. Si
tratamos de acceder al elemento guacamole[6],
estamos accediendo a lo que haya después del
último elemento del array. Los resultados son
inesperados.

5. Veamos un ejemplo de cómo pasar un array a una
función:
# include <iostream.h>void eat_at_joes(int guacamole[])
{
guacamole[0] = 1;
guacamole[1] = 2;
guacamole[2] = 3;
}
main()
{
int taco[3];
int nacho[2];
eat_at_joes(taco);
eat_at_joes(nacho);
}

6. #include <stdio.h>
double producto_escalar(double v1[], double v2[], int d);
int main()
{
const int largo = 3;
double vector_1[] = {5,1,0};
double vector_2[] = {-1,5,3};
double resultado = producto_escalar(vector_1, vector_2, largo);
// imprime el resultado
printf("(%f, %f, %f) . (%f, %f, %f) = %fn",
vector_1[0], vector_1[1], vector_1[2],
vector_2[0], vector_2[1], vector_2[2],
resultado);
return 0;
}
/* producto escalar entre dos vectores */
double producto_escalar(double v1[], double v2[], int d)
{
double resultado = 0;
int i;
for (i=0; i < d; i++) {
resultado += v1[i] * v2[i];
}
return resultado;
}