Sie sind auf Seite 1von 73

PROGRAMACIÓN ORIENTADA

A OBJETOS USANDO C++

Mg. Ing. Carolyn M. Rojas Vargas


INDICE
 Qué es Programación orientada a objetos
(POO)
 Introducción al C++.
 Librerías, tipos, usos.
 Objetos de un programa.
 Uso de operadores y tipos de datos.
Constantes y variables.
 Operadores aritméticos y lógicos, usos.
 Partes de un programa en lenguaje C++,
función de cada parte, Librerías, tipos.
 Directivas.
 Prototipos de funciones.
 Función principal, características.
PROGRAMACIÓN ORIENTADA A OBJETOS

La Programación Orientada a Objetos (POO), es un estilo de programar,


donde el programador conceptualiza el problema buscando patrones y
comportamientos (atributos y métodos) y en base a estos se crea un modelo
ideal (clase), y a partir de él se crearan instancias del modelo (objetos).
Así que básicamente consiste en crear clases, una clase es un tipo, por
ejemplo string, es la clase más usada, cuando se declara un objeto de esa
clase (variable), solamente se pueden almacenar strings, no se pueden
guardar enteros o reales.
Ejemplo
string a, b, c;
string es la clase y a, b, c son objetos (instancia de la clase string).

La Programación Orientada a Objetos se enfoca en los datos, sin descuidar los algoritmos,
esto hace de C++ la evolución del lenguaje C, pues incorpora a la Programación
estructurada la POO.
PROGRAMACIÓN ORIENTADA A OBJETOS
Elementos
Clase: Descripción abstracta de un grupo de objetos (Patrón).
Objeto: Elemento con identidad propia.
Atributo: Variables definidas en la clase.
Método: Funciones definida en la clase.
Mensaje: Acción incorporada en el objeto.
Ejemplo

#include<iostream>

using namespace std; Clase: estudiantes.


class estudiantes{
Objeto obj.
string nombre,apellido;

int codigo; Atributo: nombre, apellido,


public:
código.

void ingresar(); Métodos: ingresar, eliminar,


void eliminar(); mostrar, buscar.
void mostrar();

void buscar();}obj;
PROGRAMACIÓN ORIENTADA A OBJETOS
CLASES (CLASS)
Antes de poder definir un objeto debemos definir la clase a la que pertenece (igual que en el
ejemplo anterior debemos definir antes la estructura punto para luego poder definir las variables a
y b). La forma general de describir una clase sería más o menos:

class <nombre de la clase>{

private:
Todos los atributos;
Métodos internos que manejan memoria

public:
Métodos que manipulan lo declarado en la parte private;};

Para usarlos desde el main:


main(){

<nombre de la clase> <nombre del objeto>;

<nombre del objeto>.<nombre del método en la parte public>(<atributos>);}


EJEMPLO
Vamos a crear la clase CRONOMETRO:

class CRONOMETRO{
struct time tm; // Variable que coge la hora del sistema
int andando;
void dif_tm(time tr, time ts, time *dif);
public:
void Arranca(void);
void Muestra(void);
void Para(void);
};
CRONOMETRO p; (p será un objeto de la clase cronometro);
La función dif_tm es privada porque al resto del programa no le interesa acceder a ella, en
cambio las funciones Arranca, Muestra y Para si pueden acceder a ella porque necesitan
saber la diferencia entre dos tiempos (sobre todo la función Muestra, que es la que muestra
dicha diferencia). Para llamar a una función de la clase desde una parte del programa que
no pertenece a dicha clase, se utiliza:

nombre_objeto.funcion;
INTRODUCCÍON A C++
INTRODUCCIÓN A C++
C++ es una mejoría sobre muchas de las características de C, y proporciona capacidades de
P.O.O. que promete mucho para incrementar la productividad, calidad y reutilización del software.

En C, la unidad de programación es la función, con lo cual, se trata de una programación


orientada a la acción.

En C++, la unidad de programación es la clase a partir de la cual, los objetos son producidos. Se
trata, pues, de una programación orientada al objeto.

Las bibliotecas estándar de C++ proporcionan un conjunto extenso de capacidades de


entrada/salida. C++ usa entradas/salidas de tipo seguro; no podrán introducirse datos
equivocados dentro del sistema.

Se pueden especificar entradas/salidas de tipos definidos por el usuario, así como de tipos
estándar. Esta extensibilidad es una de las características más valiosas de este lenguaje de
programación.

C++ permite un tratamiento común de entradas/salidas de tipos definidos por usuario. Este tipo de
estado común facilita el desarrollo de software en general y de la reutilización de software en
particular. La salida de flujo puede ser ejecutada mediante el operador de inserción de flujo : <<.
Se hace la homonimia del operador << para extraer elementos de datos de tipos incorporados,
para extraer cadenas y para extraer valores de apuntadores.
TIPOS DE FICHEROS EN C++
• Fuente (.c): Uno o más ficheros escritos en ASCII con las
instrucciones del programa.
• Objeto (.o o .obj): Son ficheros intermedios creados a partir
de la compilación, entendibles por el montador y
transparentes al programador.
• Librería (.a o .lib): Reune varios ficheros objeto en uno solo.
Suelen agrupar funciones estándar.
• Cabecera (.h): Contienen definiciones y declaraciones
compartidas por varios ficheros fuente, así como las
correspondientes a las funciones estándar de las librerías.
Ejecutables (.exe): Se almacena en un único fichero todo el
código máquina de los ficheros objeto asociados al
programa, ya en un formato ejecutable.
INTRODUCCIÓN A C++

Ejemplo:

// Programa que muestra mensaje de bienvenida a C++.


// Salida de una cadena usando inserción de flujo.

# include <iostream.h>
main( )
{
cout <<''¡ Bienvenido a C++! \n'';
return 0;
}

Dichos operadores se pueden concatenar.

Todas las palabras claves de C++ están en minúsculas. En C++, las mayúsculas y minúsculas son
diferentes
C++ únicamente

C y C++ asm Medio definido por la puesta en práctica de lenguaje de ensamble a lo


largo de C++. ( Vea los manuales correspondientes a su sistema).
catch Maneja una excepción generada por un throw.
auto break case char const
class Define una nueva clase. Pueden crearse objetos de esta clase.
delete Destruye un objeto de memoria creado con new.
continue default do double else
friend Declara una función o una clase que sea un ''amigo'' de otra clase. Los
amigos pueden tener acceso a todos los miembros de datos y a todas las
enum extern float for goto
funciones miembro de una clase.
inline Avisa al compilador que una función particular deberá ser generada en
if int long register return línea, en vez de requerir de una llamada de función.

new Asigna dinámicamente un objeto de memoria en la memoria adicional


short signed sizeof static struct
disponible para el programa en tiempo de ejecución. Determina
automáticamente el tamaño del objeto.
operator Declara un operador ''homónimo''.
switch typedef union unsigned void
private Un miembro de clase accesible a funciones miembro y a funciones
volatile while friend de la clase de miembros private.
protected Una forma extendida de acceso private; también se puede tener acceso a
los miembros protected por funciones miembro de clases derivadas y
amigos de clases derivadas.
public Un miembro de clase accesible a cualquier función.

template Declara cómo construir una clase o una función, usando una variedad de
tipos.

this Un apuntador declarado en forma implícita en toda función de miembro

no static de una clase. Señala al objeto al cual esta función miembro ha


sido invocada.
throw Transfiere control a un manejador de excepción o termina la ejecución
del programa si no puede ser localizado un manejador apropiado.

try Crea un bloque que contiene un conjunto de números que pudieran

generar excepciones, y habilita el manejo de excepciones para cualquier


excepción generada.

virtual Declara una función virtual.


LIBRERIAS , TIPOS DE USO
COMENTARIOS Y DECLARACIONES EN C++
C++ permite empezar un comentario con // y usar el resto de la línea para
texto del comentario; el fin de la línea da de manera automática por terminado
el comentario. También es aceptable la forma de C : /* */.

En C++, a diferencia de C, las declaraciones pueden ser colocadas en


cualquier parte de un enunciado ejecutable, siempre y cuando las
declaraciones antecedan el uso de lo que se está declarando. También, las
variables pueden ser declaradas en la sección de inicialización de una
estructura for; dichas variables se mantienen en alcance hasta el final del
bloque en el cual la estructura for está definida.

El alcance de una variable local C++ empieza en su declaración y se extiende


hasta la llave derecha de cierre. Las declaraciones de variables no pueden
ser colocadas en la condición de una estructura while, do/while, for o if.
FLUJO DE ENTRADA/SALIDA DE C++

C++ ofrece una alternativa a las llamadas de función printf y scanf para
manejar la entrada/salida de los tipos y cadenas de datos estándar. Así, en
lugar de printf usamos el flujo estándar de salida cout y el operador <<
(''colocar en''); y en lugar de scanf usamos el flujo de entrada estándar cin y el
operador >> (''obtener de''). Estos operadores de inserción y extracción de
flujo, a diferencia de printf y scanf, no requieren de cadenas de formato y de
especificadores de conversión para indicar los tipos de datos que son
extraídos o introducidos.

Para utilizar entradas/salidas de flujo, se debe incluir el archivo de cabecera


iostream.h.
COMO CREAR NUEVO TIPO DE DATOS

C++ proporciona la capacidad de crear tipos definidos por el usuario


mediante el uso de las palabras reservadas enum, struct, union y la nueva
palabra reservada class. A diferencia de C, una enumeración ( enum ) en
C++, cuando se declara, se convierte en un tipo nuevo. Para declarar la
variable del nuevo tipo, la palabra reservada enum no es requerida. Lo mismo
para struct, union y class. Los nombres de etiqueta pueden ser utilizados para
declarar variables. Las enumeraciones por omisión son evaluadas iniciándose
en cero.
PROTOTIPOS DE FUNCION Y VERIFICACION DE
TIPOS
C++ requiere que se declaren todos los parámetros de función en los
paréntesis de la definición de función y del prototipo. Una lista vacía de
parámetros se especifica escribiendo void o absolutamente nada en los
paréntesis.
FUNCIONES EN LÍNEA
Existen funciones en línea que ayudan a reducir la sobrecarga por llamadas
de función especial para pequeñas funciones. El compilador puede ignorar el
calificador inline y típicamente así lo hará para todo, a excepción de las
funciones más pequeñas. El calificador inline deberá ser utilizado sólo
tratándose de funciones pequeñas, de uso frecuente. Usa funciones inline
puede reducir el tiempo de ejecución, pero puede aumentar el tamaño del
programa.
Ejemplo:

// Usamos la función inline para calcular el volumen de un

cubo. #include <iostream.h>

inline float cubo( const float s ) { return s * s * s; }

main( )
{
cout << ''Introduce la longitud del lado de tu cubo: '';
float lado;
cin >> lado;
cout << ''El volumen del cubo de lado ''
PARÁMETROS DE REFERENCIA
C++ ofrece parámetros por referencia. Un parámetro de referencia es un
seudónimo (''alias'') de su argumento correspondiente. Para indicar que un
parámetro de función es pasado por referencia, sólo hay que colocar un
ampersand (&) después del tipo del parámetro en el prototipo de función.

Debemos usar apuntadores para pasar argumentos que pudieran ser


modificados por la función llamada, y usar referencias a constantes para
pasar argumentos extensos, que no serán modificados.

Las variables de referencia deben ser inicializadas en sus declaraciones, y no


pueden ser reasignadas como seudónimos a otras variables.

Cuando se regresa un apuntador o una referencia a una variable declarada


en la función llamada, la variable deberá ser declarada static dentro de dicha
función.

Las referencias pueden ser usadas como argumentos de funciones y regresar


valores.
PARÁMETROS DE REFERENCIA
Ejemplo:

int ix; /* ix es la variable ''real'' */

int &rx = ix; /* rx es el ''alias'' de ix */


ix = 1; /* también rx == 1 */
rx = 2; /* también ix == 2 */
EL CALIFICADOR CONST
El calificador const se usa en la lista de parámetros de una función para
especificar que un argumento pasado a la función no es modificable en dicha
función. También puede ser utilizado para declarar las llamadas ''variables
constantes''. Estas pueden ser colocadas en cualquier parte en que se espere
una expresión constante. También en archivos de cabecera.
La variable constante debe ser inicializada al declararse.
Otro uso común para el calificador const es para poder declarar un
apuntador constante.
Tabla con expresiones de declaración de constantes:

DECLARACION NOMBRE ES...


const tipo nombre = valor; Tipo constante.
tipo *const nombre = valor; Apuntador constante a tipo.
const tipo *nombre = valor; (Variable) apuntador a la constante
tipo.
const tipo *const nombre = valor; Apuntadorconstanteatipo
constante.
FORMATO CIN AND COUT
En C++ se empieza a utilizar el concepto de flujos de E/S y no son mas que una clase (son
dos clases: CIN y COUT). Las salidas con formatos de COUT:

cout <<formato<<variable; // equivale a printf(“formato”,variable);

dec = %d (enteros)

hex = hexadecimal

oct = octal

endl = “\n” (en CIN y COUT se puede seguir poniendo “\n”)

ends = ‘\0’ (inserta el fin de cadena, un NULL, no el carácter cero)

setw (num) fija la anchura de un campo en n bytes;

cout<<setw(6)<<variable

setprecision(n) = fija el numero de decimales que queremos (n).

todas estas cosas están en la librería <iomanip.h>


FORMATO CIN AND COUT

EJEMPLO:
*Sacar un numero en tres formatos: hexadecimal, octal y decimal:
#include <iostream.h>
#include <iomanip.h>
int num;
cin<<num;
cout<<” el numero decimal es: “<<dec<<num<<endl; (endl=”\n”)
cout<<“el numero octal es: “<<dec<<oct<<endl; (endl=”\n”)
cout<<” el numero decimal es: “<<dec<<hex<<endl; (endl=”\n”)
CONSTRUCTOR Y DESTRUCTOR
Lo mas normal es que un objeto tenga que reinicializarse, para hacerlo usamos el
constructor (tiene el mismo nombre de la clase); no es necesario que se creen (en este caso
el compilador utiliza el constructor explicito que inicializa los dato en cero o NULL, según sea
el tipo de dato); cuando se encuentra una declaración de un objeto, el compilador llama al
constructor. No se debe llamar explícitamente al constructor. El formato de la función
constructora es:

nombre_clase (parámetros);

Podemos definir la función constructora para que inicialice ciertas variables, pedir memoria
dinámica, etc. El destructor no se debe llamar explícitamente, el compilador lo llama antes de
terminar el programa (cuando llega a la última llave del main). Si no existe el destructor, el
compilador llama a uno por defecto. Su formato es:

~nombre_clase (parámetros);

Si hemos reservado memoria dinámica en la función constructora, podemos aprovechar y


liberarla en la destructora.
PUNTERO THIS

 Variable predefinida para todas las funciones miembros de


la clase. (parámetro oculto)

 Es un puntero al objeto concreto de la clase al cual se le


está aplicando el método. (No es el objeto)

 En la invocación de una función miembro, el objeto es un


parámetro implícito.
PUNTERO THIS

 El puntero this contiene la dirección del objeto que activó al


método y NO es posible modificarlo.

 Al recibir el parámetro implícito, puede referenciar


directamente a las variables miembro del objeto
sin el operador punto o flecha.
PUNTERO THIS

 Un método NO puede referirse al objeto mismo como


un todo, sino que a cada una de sus partes.

 El puntero this permite referirse al objeto como tal:

*this
PUNTERO THIS

Las siguientes sentencias son equivalentes, dentro


del cuerpo del método constructor de la clase stack:

1. tope = -1;
2. this->tope = -1;
3. (*this).tope = -1
SOBRECARGA
DE
OPERADORES
SOBRECARGA DE OPERADORES

Esto se utiliza para hacer que un operador (+, -, *, /, etc.) haga


mas cosas que sumar números enteros, decimales, etc.
Podemos hacer que nos sume matrices, vectores, etc. Si
definimos el operador + para que sume matrices, no dejará de
hacer lo que hacia antes (sumar enteros, decimales, etc.).
La forma para definir la función sobrecargada es:

tipo_a_devolver nombre_clase::operator(parámetros);
SOBRECARGA DE OPERADORES
 Operaciones aritméticas para:

 Fracciones
f=f1 + f2
 Complejos
c=c1 + c2
 Vectores, etc.
v=v+k
 Operadores de flujo:
 Fracciones cout<<f;
 Complejos cin>>c;
 Vectores, etc. cout<<v;
RESTRICCIONES

 No es posible sobrecargar:

 Operador punto (.)


 If aritmético (? :)
 Operador sizeof
 Operador de resolución de alcance (::)
 Puntero a un miembro de un objeto (*.)
RESTRICCIONES

 Se
puede modificar la definición de un
operador, pero NO su gramática (número de
operandos, precedencia y asociatividad)

 Serequiere que, al menos, UN operando sea


un objeto de la clase, en la que se ha definido.

 Es
el tipo de operandos lo que determina qué
operador utilizar.
EL OPERADOR SOBRECARGADO:

1. Operador Miembro

 Operador que modifica el operando implícito


(izquierda del operador)
 Requiere que el primer operando de la función
sea un objeto de la clase (izquierda del operador)
 Contiene sólo UN parámetro

a) f1 + f2
b) f5 * f3
EJEMPLO

class Fraccion
{public:
Fraccion(int=0 ,int=1 ); // Por defecto
void Imprimir();
void SetNum(int);
void SetDen(int);
int Numerador();
int Denominador();
void Simplificar();
Fraccion operator+(const Fraccion&);

private:
int num;
int den;
int MCD();
};
EJEMPLO

Fraccion operator+(const Fraccion&);

Fraccion Fraccion::operator+(const Fraccion &f)


{ Fraccion g;
g.num=f.num*den + num*f.den;
g.den= den * f.den;
g.Simplificar();
return g;
}
EJEMPLO

class Fraccion
{public:
Fraccion(int=0 ,int=1 ); // Por defecto
void Imprimir();
void SetNum(int);
void SetDen(int);
int Numerador();
int Denominador();
void Simplificar();
Fraccion& operator+(const Fraccion&);

private:
int num;
int den;
int MCD();
};
EJEMPLO

Fraccion& operator+ (const Fraccion&);

Fraccion& Fraccion::operator+(const Fraccion& y)


{ num = num * y.den + den * y.num;
den = den * y.den;
Simplificar();
return *this;
};
EL OPERADOR SOBRECARGADO:

2. Operador Friend

 Función "Amiga" de la clase


 Operador actúa sobre varios objetos SIN
modificarlos
 Primer parámetro (objeto de la izquierda). Ahora
explícito
a) f1 + f2
b) f5 * f3
EJEMPLO

class Fraccion
{public:
Fraccion(int=0 ,int=1 ); // Por defecto
void Imprimir();
void SetNum(int);
void SetDen(int);
int Numerador();
int Denominador();
void Simplificar();
friend Fraccion operator+ (const Fraccion&,const Fraccion&);

private:
int num;
int den;
int MCD();
};
EJEMPLO

friend Fraccion operator+ (const Fraccion&,const Fraccion&);

Fraccion operator+(const Fraccion &f, const Fraccion &g)


{Fraccion h;
h.num= g.num*f.den+ f.num*g.den
h.den= g.den*f.den
return h;
}
SOBRECARGA DE
OPERADORES DE
RELACIÓN
EJEMPLO: SOBRECARGAR ==

bool operator==(const Fraccion&);

bool Fraccion::operator==(const Fraccion &f)


{return (num*f.den==den*f.num);
}

a) if (f1==f2)
b) x= (f1==f2);
SOBRECARGA DEL
OPERADOR DE
ASIGNACIÓN
EJEMPLO: SOBRECARGAR =

Fraccion& operator=(const Fraccion&);

Fraccion& operator=(const Fraccion &f)


{ if (this!=&f)
{num= f.num;
den= f.den;
}
return *this;
}

f1= f2;
DIFERENCIA
a) El constructor de Copia inicializa memoria no inicializada.

Fraccion::Fraccion(const Fraccion& k)
{num=k.num;
den=k.den;
}

Fraccion f(3,4);
Fraccion g(f);
DIFERENCIA

b) El operador de asignación
 Protege contra la "auto-asignación"
 Elimina posibles elementos antiguos
 Inicializa y copia los nuevos elementos

Fraccion& operator=(const Fraccion &f)


{ if (this!=&f)
{num= f.num;
den= f.den;
}
return *this;
}
VARIABLES DINÁMICAS

La implementación de este operador será más


interesante cuando el objeto posea variables
dinámicas:

f:
p: num: 2
den: 3
Métodos
SOBRECARGA DE
OPERADORES
<< - >>
cout <<f;
cout<<"la fracción es:"<<f;
cout<<"La suma de"<<f<<" y" <<g<<"es:"<<h;

cin>>f;
SOBRECARGA: << - >>

 Sobrecargar operadores de flujos, requiere:

a) Que el primer operando sea un objeto de la clase del:


 Flujo de entrada: istream

 Flujo de salida : ostream.


b) Que el método retorne la dirección del objeto para
que se pueda utilizar varias veces en una expresión
EJEMPLO: SOBRECARGAR <<

friend ostream& operator<< (ostream&,const Fraccion&);

ostream& operator <<(ostream &sal, const Fraccion &f)


{sal << f.num << " / " <<f.den;
return sal;
}

cout <<f;
cout<<"la fracción es:"<<f;
cout<<"La suma de"<<f<<" y" <<g<<"es:"<<h;
COMPOSICIÓN
DE
CLASES
COMPOSICIÓN DE CLASES

 Relación de pertenencia.

 Incluir objetos de una clase A como miembros de datos


de otra clase B.
CLASE MIXTO

class Mixto
{public:
Mixto();
Fraccion Equivalente();
float Equivalente();
void Listar();
private:
int ent;
Fraccion f;
};
CLASE CURSO
class Curso
{public:
Curso(int t=30);
void Inscribir(Alumno&);
void Listar();
double Promedio();
int Aprobados();
int Reprobados();
private:
int N;
char nom[25];
char cod[7];
Alumno v[50];
};
COMPOSICIÓN DE CLASES

 El constructor de la clase que contiene objetos de otras


clases llamará a los constructores de cada uno de los
objetos contenidos.

 Un constructor default de la clase, llamará implícitamente a


los constructores default de los objetos miembros de una
clase que componen la clase inicial
CONSTRUCTOR ALUMNO

Alumno::Alumno()
{k=0; t=0;}

Alumno::Alumno(char *n, char *r, int m, int c)


{strcpy(nom,n);
strcpy(rut,r);
mat=m;
carrera=c;
k=0;
t=0;
}
CONSTRUCTOR CURSO

Curso::Curso(int t)
{N=t; Objeto
cin.getline(nom,25); anónimo
Invocación
cin.getline(cod,7); explícita al
constructor
char *x, *y;
int z,c;
for (int i=0;i<N;i++)
{
cout<<"NOMBRE: "; cin.getline(x,20);
cout<<"RUT : "; cin>>y;
cout<<"MAT : "; cin>>z;
cout<<"Carr : "; cin>>c;
Alumno a(x,y,z,c);
v[i]= a; }}
LISTAR

void Curso::Listar()
{for (int i=0;i<N;i++)
T[i].Listar(); }

void main()
{Curso C;
C.Listar();
}
COMPOSICIÓN DE CLASES

class Fecha class Empleado objetos


{private: {private: de
int dia; char *nom; clase
int mes; char *app; Fecha
int año; float sueldo;
int ValidaDia(); Fecha fnac;
public: Fecha fcontr;
Fecha(int,int,int) public:
;
void Imprimir(); Empleado(char*, char*, float, int,
int, int, int, int, int);
}
void Imprimir();
}
Composición de clases

 Los constructores inicializan miembros de datos.

 Éstos se invocan en el constructor de la clase


contenedora

 Por lo tanto, ANTES de inicializar los datos de la


clase contenedora (Mixto, Curso, Empleado)
deberán inicializarse aquellos datos que sean
objetos de otras clases, por medio, de sus
constructores.
COMPOSICIÓN DE CLASES

Empleado::Empleado( char *n, char*a, float s, int nd, int nm, int na,
int cd, int cm, int ca) : fnac(nd,nm,na), fcontr(cd,cm,ca)
{ strncpy(nom,n,24);
strncpy(app,a,24);
inicializació
sueldo=s;
n de objetos
} de clase
fecha
void Empleado::Imprimir()
{cout<< "Nom: "<<nom; "Apellido: "<< app<<"Sueldo: "<<s;
fnac.Imprimir();
fcontr.Imprimir(); Llamada a métodos
} de la clase Fecha
USO DE LA CLASE EMPLEADO

#include "empldef.h"

void main()
{Empleado x("Juan", "Pérez", 650.000,1,10,65,15,10,2000);
x.Imprimir();
}
PLANTILLAS
DE
FUNCIONES
PLANTILLAS DE FUNCIONES

Mecanismo para implementar funciones genéricas

template <classT>
tipo nombre(parámetros)
{sentencias}
EJEMPLO

template <class T> void main()


void Swap(T&a , T&b) {int r=5,s=7;
Swap(r,s)
{T aux;
cout<<r<<s<<endl;
aux= a;
double x=1.1, y=3.3;
a= b; Swap(x,y);
b= aux; cout<<r<<s<<endl;
} }
PLANTILLAS DE FUNCIONES

void main()
{ int V[5];
Crear(V,5);
Listar(V,5);

float X[4];
Crear(X,4);
Listar(X,4);

char C[6];
Crear(C,6);
Listar(C,6);
}
PLANTILLAS DE FUNCIONES

template <class T>


void Crear(T v[], int n)
{for (int i=0;i<n;i++)
cin>>v[i];
}

template <class T>


void Listar(T v[], int n)
{for (int i=0;i<n;i++)
cout<<v[i];
}
PLANTILLAS
DE
CLASES
PLANTILLAS DE CLASES

Clases
Mecanismo para implementar:
genéricas

template<class T>
class nombre
{private:
Métodos
Variables
public:
Métodos
Variables
}
template <class T>
class Stack
{private:
T *p;
int top;
int largo;
bool Full();
public:
Stack(int s=10);
bool Empty();
PLANTILLA
boolDE CLASES
Push(T);
T Pop();
~Stack();
};
MÉTODOS

template <class T> template <class T>


Stack<T>::Stack(int s) bool Stack<T>::Push(T e)
{largo = s; { if (!Full())
top = -1; { p[++top]=e;
p=new T[largo];
return true;
}
}
return false;
}
template <class T>
bool Stack<T>::Empty() template <class T>
{return top==-1;} Stack<T>::~Stack()
{delete [ ] p;}
USO DE CLASES GENÉRICAS

void main()
{ Stack<int> S,S2;
Poblar(S);
Listar(S);
S2=S;
Listar(S2);
Stack<float> S3;
Poblar(S3);
Listar(S3);
Invertir(S3);
Ordenar(S1,S2)
}
GRACIAS