Presentación

Nombre: Yerinson Pérez Feliz

Matricula: 100246818

Tema: Programación Genérica

Profesora: Noemí Cuevas Sánchez

Fecha: 05/12/2020
Concepto de programación genérica.
La programación genérica es un tipo de programación que está mucho más
centrada en los algoritmos que en los datos. La idea de esta forma de
programar pretende generalizar las funciones utilizadas para que puedan
usarse en más de una ocasión.
Esto se consigue parametrizando lo máximo posible el desarrollo del programa
y expresados o devueltos de la forma más simple posible, evitando detalles
concretos.
La biblioteca de funciones conseguida con esta manera de programa permite
que esas funciones puedan servir para más programas de los que, otras más
concretas, podrían ser útiles; y también aplicando pocos cambios, conseguir
que realice diferentes acciones.
¿Para qué sirve? Beneficios.
Los genéricos permiten personalizar un método, clase, estructura o interfaz con
respecto a los datos precisos sobre los que se actúa. Por ejemplo, en lugar de
utilizar la clase Hashtable, que permite cualquier tipo de clave y valor, puede
utilizar la clase genérica Dictionary<TKey,TValue> y especificar los tipos
permitidos para la clave y el valor. Entre las ventajas de los genéricos están
una mayor reutilización del código y la seguridad de tipos.
Explicar el concepto de plantillas o templates en programación genérica.
En esta nota estudiaremos una característica genial de C++, se trata de
las plantillas o templates. Una plantilla es una manera especial de escribir
funciones y clases para que estas puedan ser usadas con cualquier tipo de
dato, similar a la sobrecarga, en el caso de las funciones, pero evitando el
trabajo de escribir cada versión de la función. Las ventajas son mayores en el
caso de las clases, ya que no se permite hacer sobrecarga de ellas y
tendríamos que decidirnos por una sola o hacer especializaciones usando la
herencia. 
¿Cómo funcionan?
La magia de las plantillas está en no definir un tipo de dato desde el principio,
sino dejar esto como algo pendiente y usar algo que permita manejar varias
opciones, de hecho, se usa una variable para este propósito. Veamos la
sintaxis para el caso de las funciones:
// Para una función, ambas opciones son equivalentes
template <class identificador> definición_de_función;
template <typename identificador> definición_de_función;
El identificador es el símbolo que guarda el tipo de dato que se ha de usar una
vez elegido, por lo que en la definición de la función deberá utilizarse en lugar
de los nombres de los tipos de datos, de esta manera queda hecha una función
genérica a la cual podemos llamar función-plantilla.
Tal vez con un ejemplo esta idea quede más clara. Pensemos en una función
que nos retorne el mayor de dos datos que le demos como argumentos y que
sirva con cualquier tipo:
template <class tipo>
tipo mayor(tipo dato1, tipo dato2){
return (dato1 > dato2 ? dato1 : dato2);
}
El identificador que usamos es “tipo”, por eso el tipo de dato de retorno y el de
los parámetros debe ser ese identificador. Durante la compilación del
programa, en la invocación a la función, se resuelve el tipo que se usará y el
compilador escribirá, con base en la plantilla, una función que sirva con el tipo
de dato resuelto y será la que realmente se utilice para dicha invocación.

Se puede usar una especificación explícita para el tipo de dato que se usará en
la función escribiendo <tipo dato> o dejar que el compilador resuelva el tipo con
los argumentos. Cabe destacar que las plantillas funcionan no solo con tipos de
datos primitivos sino también con los estructurados como las clases, aunque
para nuestro ejemplo debemos tener sobrecargado el operador
de comparación usado en la definición de la función “>”.

La función no sirve cuando los tipos de los datos son diferentes, entonces no
podríamos usarla con un entero y un real, porque solamente se ha definido
un identificador de tipo. Para usar más tipos basta con definir más
identificadores, de esta manera podríamos escribir la función de la siguiente
forma:
template <class tipo1, class tipo2>
tipo1 mayor(tipo1 dato1, tipo2 dato2){
return (dato1 > dato2 ? dato1 : dato2);
}
Con esta función es posible una llamada así:

int a = 10;
float b = 11.0;
float c = mayor(b,a); // como el primer argumento es un float, el resultado
también lo es
Clases-plantilla
Como mencioné al principio de la nota, podemos escribir también clases con
plantillas, llamadas clases-plantilla, y crear objetos que sirvan con cualquier tipo
de dato, esta característica es de gran ayuda al momento de escribir, por
ejemplo, una clase para arreglos o para matrices que sirven con cualquier tipo
y no solo con uno.

En este caso, el identificador de tipo sirve en toda la definición de la clase, ya

sea para los atributos o los métodos, a continuación, tenemos la sintaxis para
declarar una clase-plantilla:
template <class identificador> definición_de_clase;
// Para las funciones miembro definidas fuera de la clase
template <class identificador>
tipo retorno nombre clase<identificador>::nombre función(argumentos){
// implementación
}
Se entiende mejor la idea con un ejemplo, veamos algo simple:
template <class T> //identificador de tipo: T
class Coordenada {
private:
T x; //atributos de tipo T
T y;

public:
Coordenada (T x=0, T y=0); //parámetros de tipo T
T dameX(){return x};
T dameY(){return y}; //retorna un tipo T
void nuevoX(T x){this -> x = x};
void nuevoY(T y){this -> y = y};
}

template <class T>

Coordenada<T>::Coordenada(T x, T y){
this -> x = x;
this -> y = y;
}
Con esta clase podemos instanciar objetos que representan coordenadas de
cualquier tipo de dato, por ejemplo:
// Una coordenada de enteros
Coordenada <int> c1(1,2);
// Una coordenada de reales
Coordenada <float> c2(1.5, 0.5);
Para el caso de las clases, sí es necesario especificar explícitamente el tipo:
Tipos o categoría de contenedores. 
Contenedor (tipo de dato abstracto)
Ir a la navegaciónIr a la búsqueda
En programación orientada a objetos, un container es un delimitador abstracto,
es decir, un objeto que contiene otros objetos que pueden ser incluidos o
eliminados dinámicamente (durante el tiempo de ejecución), a diferencia de lo
que ocurre en una composición en la que esta relación se fija durante el tiempo
de compilación.
Container Java Enterprise Edition[editar]
En Java EE, el «contenedor» provee los componentes construidos
como servlets (contenedor para aplicaciones web) o EJBs (contenedor para
componentes de negocio). Un ejemplo de contenedor para web es el Tomcat.
Cuando una aplicación web realiza una solicitud para un servlet, el servidor no
entrega la solicitud directamente al servlet, sino al contenedor que contiene el
servlet. El contenedor maneja el ciclo de vida, soporta el subproceso,
seguridad, y soporte para páginas JSP, en el caso de los contenedores web.
Conclusión
Con el objeto de explicar la razón de la necesidad de la existencia de las
plantillas debemos reflexionar sobre tres paradigmas de programación
anteriores, estas son: programación clásica o procedimental, programación
estructurada y programación orientada al objeto POO.
Programación clásica.

En el tipo de programación conocida como clásica existe una clara

diferenciación entre los datos y su manipulación, es decir, entre los datos y el
conjunto de algoritmos para manejarlos. Los datos son tipos muy simples y
generalmente los algoritmos se agrupan en funciones orientadas de forma muy
específica a los datos que deben manejar. Por ejemplo, si se escribe una
función ( sort ) para ordenar en forma ascendente o descendente los números
contenidos en un arreglo de números enteros, dicha función puede aplicarse a
cualquier arreglo de enteros más no a arreglos de otro tipo. Aun así, la
programación clásica provee el soporte necesario para la reutilización de
código ya que el código de la función se escribe solamente una vez y su
reutilización se da por medio de un mecanismo conocido como llamada de
función.
Programación estructurada

En la medida en que los datos que había de manipular se iban haciendo cada
vez más complejos se buscó la forma de agruparlos de alguna manera bajo un
mismo nombre, es así como surgen las estructuras de datos. Muchos autores
se refieren a la programación estructura como a la suma de funciones y/o
procedimientos más estructura de datos.
Programación Orientada al Objeto

La Programación Orientada al Objeto ( POO ) introduce nuevas facilidades y se

extiende el concepto de dato, permitiendo que existan tipos más complejos, es
decir, si la programación estructurada establece las bases para la manipulación
de funciones y datos estructurados, la POO establece las bases para manipular
datos y funciones como un solo objeto. Esta nueva habilidad viene
acompañada por ciertas mejoras adicionales: la posibilidad de ocultación de
determinados detalles internos irrelevantes para el usuario y la capacidad de
herencia simple o múltiple.
Notas: El ocultamiento de código así como la herencia están presentes ( en
una forma simple ) en la programación estructurada, y los mismos adquieren
mucha más relevancia en la POO. Por ejemplo, en la programación
estructurada si usted escribe una librería de funciones, al usuario de dicha
librería solamente le informará de la existencia de tal o cual función, así como
el objetivo y la forma correcta para comunicarse con estas, pero no es
necesario que se le explique el funcionamiento interno de las mismas. Por otro
lado, es bien conocido que lenguajes tales como Pascal y C, por ejemplo, dan
el soporte para la creación de datos estructurados (Record en Pascal, y struct
en C), y que dichas estructuras pueden contener a otras estructuras
previamente definidas. De tal manera vemos como a los usuarios de las
funciones se les oculta el código de las mismas, y que una estructura que
contiene a otra hereda los miembros de la estructura contenida.
Programación genérica
La programación genérica está mucho más centrada en los algoritmos que en
los datos, y su postulado fundamental puede sintetizarse en una palabra:
generalización. Significa que, en la medida de lo posible, los algoritmos deben
ser parametrizados al máximo y expresados de la forma más independiente
posible de detalles concretos, permitiendo así que puedan servir para la mayor
variedad posible de tipos y estructuras de datos.