Conjunto

(6&8(/$32/,7e&1,&$1$&,21$/
&$55(5$'(,1*(1,(5Ë$'(6,67(0$6
352*5$0$&,Ï1,,
$OXPQR Adrián F. Vaca Cárdenas.

&XUVR GR1
6HPHVWUH Octubre/2000 - Marzo/2001
)HFKD 08 - 03 - 2001
, 7(0$
3/$17,//$6
,, 2%-(7,926
Comprender que son las funciones virtuales y el polimorfismo, el uso y

aplicaciones que tienen estos, en el desarrollo de la programación
orientada o objetos.
Entender que son las plantillas, el uso que estas tienen, la forma en
que se deben aplicar y las ventajas que nos presentan en el desarrollo
de aplicaciones
,,, 0$5&27(Ï5,&2
3ODQWLOODV
Las plantillas nos permiten especificar, con un solo segmento de código,

un rango completo de funciones relacionadas (sobrecargadas), llamadas
IXQFLRQHV GH SODQWLOOD, o un rango completo de clases relacionadas,
llamadas FODVHVGHSODQWLOOD.
Podríamos escribir una sola plantilla de función para una función de

ordenamiento de arreglos y luego hacer que C++ generara automáticamente
funciones de plantilla separadas que ordenaran un arreglo de LQW, un
arreglo de IORDW, un arreglo de VWULQJ, etc.
Podríamos escribir una sola plantilla de clase de pila y luego hacer que
C++ generara automáticamente clases de plantillas separadas, tales como
una clase de pila de LQW, una clase de pila de IORDW, una clase de pila
de VWULQJ, etc.
Hay que observar la diferencia entre las plantillas de función y las

funciones de plantilla: las plantillas de función y las plantillas de
clase son como plantillas con las cuales trazamos formas, y las funciones
de plantilla y las clases de plantilla son como los trazos separados, que
tienen la misma forma pero pueden trazarse en colores diferentes, por
ejemplo.
3ODQWLOODVGHIXQFLyQ
Las funciones sobrecargadas se utilizan normalmente para realizar

operaciones similares sobre diferentes tipos de datos. Si las operaciones
son idénticas para cada tipo, esto puede realizarse en forma más compacta
y conveniente mediante el uso de plantillas de función. Basándose en los
tipos de argumento que se proporcionan en las llamadas a esa función, el
compilador genera automáticamente funciones de código objeto separadas
para manejar adecuadamente cada tipo de llamada. En C esta tarea se puede
realizar mediante macros creadas con la directiva de preprocesador
GHILQH. Sin embargo las macros presentan la posibilidad de serios
efectos secundarios y no permiten que el compilador realice revisión de
tipo. Las plantillas de función proporcionan una solución compacta
similar a la de las macros, pero permiten una revisión de tipo completa.
Todas las definiciones de plantillas de función comienzan con la palabra
clave WHPSODWH, seguida de una lista de parámetros formales para dicha
plantilla encerrados entre paréntesis angulares ( y !), cada parámetro
formal que representa un tipo debe estar precedido por la palabra clave
FODVV, como en:
template <class T>

template <class Element Type>
template <class BorderType, class FillType>
Los parámetros formales de una definición de plantilla se utilizan (como

sucedería con los argumentos de tipos integrados o de tipos definidos por
el usuario) para especificar los tipos de argumentos de la función, para
especificar el tipo de devolución de la función y para declarar variables
en el interior de la función.
Para definir una plantillas de clase, se puede usar el siguiente formato:

template <class T>
class Nombre { ...uso del parámetro T en funciones o datos
miembro.. }
,9 '(6$552//2
El presente ejercicio, se refiere a una plantilla de una clase básica:

"conjunto", en la que se puede llevar a cabo operaciones como: ingresar,
eliminar e imprimir elementos, además de: sumar conjuntos y verificar si
un conjunto dado está vacío.
Un explicación de cada función se presenta a continuación:
En primer lugar, se define una enumeración, con los valores de IDOVH y

WUXH, para llevar a cabo ciertas operaciones.
En primer lugar se define la clase plantilla FRQMXQWR.

Los datos miembro son: un puntero, que contendrá los elementos del
conjunto, y un entero que almacena el número de elementos del conjunto.
Las funciones miembro son:
Un constructor por defecto con los valores de 0 y 0, a ser asignados a
cada uno de los datos miembro de la clase.
Un destructor, que se encarga de colocar los dos datos miembro a 0, este
se emplea cuando ya no se quiere hacer uso de un objeto de la clase.
YRLGLQJUHVDUBHOHPHQWR 7
Esta función se usa cuando el usuario quiere ingresar un nuevo elemento

en el conjunto, la función recibe, el dato a insertar, para esto, en
primer lugar se incrementa el número de elementos del conjunto en 1, y
luego se procede a insertar el elemento en cuestión. El elemento es
insertado al final del arreglo, es decir que pasa a ser el último
elemento del conjunto.
YRLGHOLPLQDUBHOHPHQWR 7
Esta función se usa cuando se quiere eliminar un elemento del conjunto.

En primer lugar se procede a buscar el elemento dado en el arreglo de la
clase que contiene los elementos, una vez hallado, se procede a desplazar
uno a uno los elementos hacia la izquierda, a partir del índice del
elemento que se quiere eliminar, finalmente se disminuye en uno el número
de elementos del conjunto.
YRLGLPSULPLU
Esta función se usa para imprimir uno a uno, los elementos del conjunto,
para esto se usa un ciclo IRU y se toma en cuenta el número de elementos
del conjunto.
FRQMXQWR7!RSHUDWRU FRQMXQWR7!
Esta función "sobrecarga", el operador , para poder concatenar dos

conjuntos. Se declara un objeto auxiliar de la clase, al que se asignan
los elementos del objeto implícito, luego se usa la función
ingresar_elemento, para colocar los elementos del sumando izquierdo, es
decir el que recibe como parámetro la función.
ERRORSHUDWRU
Aquí se sobrecarga el operador , para poder verificar si un conjunto

dado, esta vacío o no, para lo cual se verifica si el número de elementos
del conjunto es 0 o no.
Lo que sigue es el código fuente del programa:
#include <iostream.h>
#include <conio.h>
enum bool { false, true };
template <class T>

class conjunto {
T * elementos;
int num_elementos;
public:
conjunto (T * =0, int=0);
~conjunto();
void ingresar_elemento(T);
void eliminar_elemento(T);
void imprimir();
conjunto<T> operator+ (conjunto<T> );
bool operator ! ();
};
template <class T>

conjunto <T> :: conjunto (T * elem, int num) {
num_elementos=num;
elementos=elem;
}
template <class T>

conjunto <T> :: ~conjunto(){
elementos=0;
num_elementos=0;
}
template <class T>
void conjunto <T> :: ingresar_elemento (T elem){
num_elementos++;
elementos[num_elementos-1]=elem;
}
template <class T>

void conjunto <T> :: eliminar_elemento (T elem){
for (int i=0; i<num_elementos; i++)
if(elementos[i]==elem){
for (int j=i; j<num_elementos; j++)
elementos[j]=elementos[j+1];
elementos[num_elementos-1]=0;
num_elementos--;
cout<<"\nElemento: " << elem <<" eliminado !";
return;
}
cout<< "\nElemento no hallado";

}
template <class T>

void conjunto <T> :: imprimir(){
for(int i=0; i<num_elementos; i++)
cout<< elementos [i] << " ";
}
template <class T>

conjunto<T> conjunto <T> :: operator+ (conjunto<T> der){
conjunto<T> aux;
aux.num_elementos=num_elementos;
aux.elementos=elementos;
for (int i=0; i < der.num_elementos; i++)

aux.ingresar_elemento(der.elementos[i]);
return aux;
}
template <class T>

bool conjunto <T> :: operator! () {
if (!num_elementos) return true;
return false;
}
void main(){
clrscr();
int aux1[3]= { 4, 8, 12 };
conjunto <int> A(aux1,3);
cout<<"Conjunto A: ";
A.imprimir();
cout<<"\n\nIngresando elemento: 20 en A ...";

A.ingresar_elemento(20);
cout<<"\nNuevo conjunto A: ";
A.imprimir();
cout<<"\n\nEliminando elemento: 8 de A ...";

A.eliminar_elemento(8);
cout<<"\nA: ";
A.imprimir();
cout<<"\n\nEliminando elemento 3 de A ...";

A.eliminar_elemento(3);
cout<<"\nA: ";
A.imprimir();
int aux2[3]= { 2, 8, 15};

conjunto <int> B(aux2,3);
cout<<"\n\nConjunto B: ";
B.imprimir();
conjunto <int> C(0,0);

cout<<"\n\nEfectuando: C= A + B ...";
C=A+B;
cout<<"\nConjunto C: ";
C.imprimir();
cout<<"\n\nProbando si B est vac¡o ...";

if(!B) cout<<"\nB est vac¡o";
else cout<<"\nB no est vac¡o";
getch();
}
A continuación se presenta una pantalla de la ejecución del programa:

9 &21&/86,21(6<5(&20(1'$&,21(6
Si se llama a una plantilla con un tipo de clase definida por el

usuario, y si dicha plantilla utiliza operadores (como ==, +, <=, etc)
con objetos de ese tipo de clase, estos operadores deben estar
sobrecargados.
Las plantillas de función, al igual que las macros, permiten la

reutilización del software. Pero a diferencia de las macros, las
plantillas de función ayudan a eliminar muchos tipos de errores debido
al escrutinio de la revisión de tipo C++.
9, %,%/,2*5$)Ë$
&RPRSURJUDPDUHQ&&
Deitel y Deitel Editorial: Prentice Hall

Conjunto

Cargado por

Copyright:

Formatos disponibles

Conjunto

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Conjunto

Cargado por

Copyright:

Formatos disponibles

(6&8(/$32/,7e&1,&$1$&,21$/

$OXPQR Adrián F. Vaca Cárdenas.

Comprender que son las funciones virtuales y el polimorfismo, el uso y

Las plantillas nos permiten especificar, con un solo segmento de código,

Podríamos escribir una sola plantilla de función para una función de

Hay que observar la diferencia entre las plantillas de función y las

Las funciones sobrecargadas se utilizan normalmente para realizar

template <class T>

Los parámetros formales de una definición de plantilla se utilizan (como

Para definir una plantillas de clase, se puede usar el siguiente formato:

El presente ejercicio, se refiere a una plantilla de una clase básica:

En primer lugar, se define una enumeración, con los valores de IDOVH y

En primer lugar se define la clase plantilla FRQMXQWR.

Esta función se usa cuando el usuario quiere ingresar un nuevo elemento

Esta función se usa cuando se quiere eliminar un elemento del conjunto.

Esta función "sobrecarga", el operador , para poder concatenar dos

Aquí se sobrecarga el operador , para poder verificar si un conjunto

Lo que sigue es el código fuente del programa:

enum bool { false, true };

template <class T>

template <class T>

template <class T>

template <class T>

cout<< "\nElemento no hallado";

template <class T>

template <class T>

for (int i=0; i < der.num_elementos; i++)

template <class T>

cout<<"\n\nIngresando elemento: 20 en A ...";

cout<<"\n\nEliminando elemento: 8 de A ...";

cout<<"\n\nEliminando elemento 3 de A ...";

int aux2[3]= { 2, 8, 15};

conjunto <int> C(0,0);

cout<<"\n\nProbando si B est vac¡o ...";

A continuación se presenta una pantalla de la ejecución del programa:

Si se llama a una plantilla con un tipo de clase definida por el

Las plantillas de función, al igual que las macros, permiten la

Deitel y Deitel Editorial: Prentice Hall

También podría gustarte

$OXPQR Adrián F. Vaca Cárdenas.

Esta función "sobrecarga", el operador , para poder concatenar dos