PROGRAMACIN ORIENTADA

A OBJETOS USANDO C++

Mg. Ing. Carolyn M. Rojas Vargas

INDICE
Qu es Programacin orientada a objetos
(POO)
Introduccin al C++.
Libreras, tipos, usos.
Objetos de un programa.
Uso de operadores y tipos de datos.
Constantes y variables.
Operadores aritmticos y lgicos, usos.
Directivas.
Prototipos de funciones.
Funcin principal, caractersticas.
PROGRAMACIN ORIENTADA A OBJETOS

La Programacin Orientada a Objetos (POO), es un estilo de programar, donde el

programador conceptualiza el problema buscando patrones y comportamientos
(atributos y mtodos) y en base a estos se crea un modelo ideal (clase), y a partir
de l se crearan instancias del modelo (objetos).
As que bsicamente consiste en crear clases, una clase es un tipo, por ejemplo
string, es la clase ms 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 Programacin Orientada a Objetos se enfoca en los datos, sin descuidar los algoritmos, esto
hace de C++ la evolucin del lenguaje C, pues incorpora a la Programacin estructurada la POO.
PROGRAMACIN ORIENTADA A OBJETOS
Elementos
Clase: Descripcin abstracta de un grupo de objetos (Patrn).
Objeto: Elemento con identidad propia.
Atributo: Variables definidas en la clase.
Mtodo: Funciones definida en la clase.
Mensaje: Accin 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:
cdigo.

void ingresar(); Mtodos: ingresar, eliminar,

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

void buscar();}obj;
 PROGRAMACIN 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 sera ms o menos:

class <nombre de la clase>{

private:
Todos los atributos;
Mtodos internos que manejan memoria

public:
Mtodos 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 mtodo 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 funcin 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 funcin Muestra, que es la que muestra
dicha diferencia). Para llamar a una funcin de la clase desde una parte del programa que
no pertenece a dicha clase, se utiliza:

nombre_objeto.funcion;
INTRODUCCON A C++
 INTRODUCCIN A C++
C++ es una mejora sobre muchas de las caractersticas de C, y proporciona capacidades de
P.O.O. que promete mucho para incrementar la productividad, calidad y reutilizacin del software.

En C, la unidad de programacin es la funcin, con lo cual, se trata de una programacin

orientada a la accin.

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

Las bibliotecas estndar de C++ proporcionan un conjunto extenso de capacidades de

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

Se pueden especificar entradas/salidas de tipos definidos por el usuario, as como de tipos

estndar. Esta extensibilidad es una de las caractersticas ms valiosas de este lenguaje de
programacin.

C++ permite un tratamiento comn de entradas/salidas de tipos definidos por usuario. Este tipo de
estado comn facilita el desarrollo de software en general y de la reutilizacin de software en
particular. La salida de flujo puede ser ejecutada mediante el operador de insercin 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 ms ficheros escritos en ASCII con las
instrucciones del programa.
Objeto (.o o .obj): Son ficheros intermedios creados a partir
de la compilacin, entendibles por el montador y
transparentes al programador.
Librera (.a o .lib): Reune varios ficheros objeto en uno solo.
Suelen agrupar funciones estndar.
Cabecera (.h): Contienen definiciones y declaraciones
compartidas por varios ficheros fuente, as como las
correspondientes a las funciones estndar de las libreras.
Ejecutables (.exe): Se almacena en un nico fichero todo el
cdigo mquina de los ficheros objeto asociados al
programa, ya en un formato ejecutable.
INTRODUCCIN A C++

Ejemplo:

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

// Salida de una cadena usando insercin de flujo.

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

Dichos operadores se pueden concatenar.

Todas las palabras claves de C++ estn en minsculas. En C++, las maysculas y minsculas son
diferentes
 C++ nicamente

C y C++ asm Medio definido por la puesta en prctica de lenguaje de ensamble a lo

largo de C++. ( Vea los manuales correspondientes a su sistema).
catch Maneja una excepcin 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 funcin 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 funcin particular deber ser generada en
if int long register return lnea, en vez de requerir de una llamada de funcin.

new Asigna dinmicamente un objeto de memoria en la memoria adicional

short signed sizeof static struct
disponible para el programa en tiempo de ejecucin. Determina
automticamente el tamao del objeto.
operator Declara un operador ''homnimo''.
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; tambin 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 funcin.

template Declara cmo construir una clase o una funcin, usando una variedad de
tipos.

this Un apuntador declarado en forma implcita en toda funcin de miembro

no static de una clase. Seala al objeto al cual esta funcin miembro ha

sido invocada.
throw Transfiere control a un manejador de excepcin o termina la ejecucin
del programa si no puede ser localizado un manejador apropiado.

try Crea un bloque que contiene un conjunto de nmeros que pudieran

generar excepciones, y habilita el manejo de excepciones para cualquier

excepcin generada.

virtual Declara una funcin virtual.

LIBRERAS , TIPOS, FUNCIONES
LIBRERAS DE C++

* FILE *fopen(const char *filename, const char *mode)

* FILE *freopen(const char *filename, const char *mode, FILE
*stream)
* int fflush(FILE *stream)
* int fclose(FILE *stream)
* int remove(const char *filename)
* int rename(const char *oldname, const char *newname)
* FILE *tmpfile(void)
* char *tmpnam(char s[L_tmpnam])
* int setvbuf(FILE *stream, char *buf, int mode, size_t size)
* void setbuf(FILE *stream, char *buf)
* int fprint(FILE *stream, const char *format, )
* int sprintf(char *s, const char *format, )
* vprintf(const char *format, va_list arg)
* vfprintf(FILE *stream, const char *format, va_list arg)
LIBRERAS DE C++
* vsprintf(char *s, const char *format, va_list arg)
* int fscanf(FILE *stream, const char *format, )
* int scanf(const char *format, )
* int sscanf(char *s, const char *format, )
* int fgetc(FILE *stream)
* char *fgets(char *s, int n, FILE *stream)
* int fputc(int c, FILE *stream)
* int fputs(const char *s, FILE *stream)
* int getc(FILE *stream)
* int getchar(void)
* char *gets(char *s)
* int putc(int c, FILE *stream)
* int putchar(int c)
* int ungetc(int c, FILE *stream)
 TESTS: <CTYPE.H>

* isalnum(c)
* isalpha(c)
* iscntrl(c)
* isdigit(c)
* isgraph(c)
* islower(c)
* isprint(c)
* ispunct(c)
* isspace(c)
* isupper(c)
* isxdigit(c)
<STRING.H>
* char *strcpy(s , ct)
* char *strncpy(s , ct , n)
* char *strcat(s , ct)
* char *strncat(s , ct , n)
* int strcmp(cs , ct)
* int strncmp(cs , ct ,n)
* char *strchr(cs , c)
* char *strrchr(cs , c)
* size_t strspn(cs , ct)
* size_t strcspn(cs , ct)
* char *strstr(cs , ct)
* size_t strlen(cs)
* char *strerror(n)
* char *strtok(s , ct)
MATHEMATICAL FUNCTIONS: <MATH.H>
* sin(x)
* cos(x)
* tan(x)
* asin(x)
* acos(x)
* atan(x)
* atan2(x)
* sinh(x)
* cosh(x)
* tanh(x)
UTILITY FUNCTIONS: <STDLIB.H>
* double atof(const char *s)
* int atoi(const char *s
* long atol(const char *s)
* double strrod(const char *s, char **endp)
* long strtol(const char *s, char **endp, int base)
* unsigned long strtoul(const char *s, char **endp, int
base)
* int rand(void)
* void srand(unsigned int seed)
* void *calloc(size_t nobj, size_t size)
* void *malloc(size_t size)
* void *realloc(void *p, size_t size)
COMENTARIOS Y DECLARACIONES EN C++
C++ permite empezar un comentario con // y usar el resto de la lnea para
texto del comentario; el fin de la lnea da de manera automtica por terminado
el comentario. Tambin 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. Tambin, las
variables pueden ser declaradas en la seccin de inicializacin 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 declaracin y se extiende

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

C++ ofrece una alternativa a las llamadas de funcin printf y scanf para
manejar la entrada/salida de los tipos y cadenas de datos estndar. As, en
lugar de printf usamos el flujo estndar de salida cout y el operador <<
(''colocar en''); y en lugar de scanf usamos el flujo de entrada estndar cin y el
operador >> (''obtener de''). Estos operadores de insercin y extraccin de
flujo, a diferencia de printf y scanf, no requieren de cadenas de formato y de
especificadores de conversin para indicar los tipos de datos que son
extrados 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 enumeracin ( 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 omisin son evaluadas inicindose
en cero.
PROTOTIPOS DE FUNCION Y VERIFICACION DE
TIPOS
C++ requiere que se declaren todos los parmetros de funcin en los
parntesis de la definicin de funcin y del prototipo. Una lista vaca de
parmetros se especifica escribiendo void o absolutamente nada en los
parntesis.
FUNCIONES EN LNEA
Existen funciones en lnea que ayudan a reducir la sobrecarga por llamadas
de funcin especial para pequeas funciones. El compilador puede ignorar el
calificador inline y tpicamente as lo har para todo, a excepcin de las
funciones ms pequeas. El calificador inline deber ser utilizado slo
tratndose de funciones pequeas, de uso frecuente. Usa funciones inline
puede reducir el tiempo de ejecucin, pero puede aumentar el tamao del
programa.
Ejemplo:

// Usamos la funcin 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 ''
PARMETROS DE REFERENCIA
C++ ofrece parmetros por referencia. Un parmetro de referencia es un
seudnimo (''alias'') de su argumento correspondiente. Para indicar que un
parmetro de funcin es pasado por referencia, slo hay que colocar un
ampersand (&) despus del tipo del parmetro en el prototipo de funcin.

Debemos usar apuntadores para pasar argumentos que pudieran ser

modificados por la funcin llamada, y usar referencias a constantes para
pasar argumentos extensos, que no sern modificados.

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

pueden ser reasignadas como seudnimos a otras variables.

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

en la funcin llamada, la variable deber ser declarada static dentro de dicha
funcin.

Las referencias pueden ser usadas como argumentos de funciones y regresar

valores.
PARMETROS DE REFERENCIA
Ejemplo:

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

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

ix = 1; /* tambin rx == 1 */
rx = 2; /* tambin ix == 2 */
EL CALIFICADOR CONST
El calificador const se usa en la lista de parmetros de una funcin para
especificar que un argumento pasado a la funcin no es modificable en dicha
funcin. Tambin puede ser utilizado para declarar las llamadas ''variables
constantes''. Estas pueden ser colocadas en cualquier parte en que se espere
una expresin constante. Tambin en archivos de cabecera.
La variable constante debe ser inicializada al declararse.
Otro uso comn para el calificador const es para poder declarar un
apuntador constante.
Tabla con expresiones de declaracin 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 carcter 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 estn en la librera <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, segn sea
el tipo de dato); cuando se encuentra una declaracin de un objeto, el compilador llama al
constructor. No se debe llamar explcitamente al constructor. El formato de la funcin
constructora es:

nombre_clase (parmetros);

Podemos definir la funcin constructora para que inicialice ciertas variables, pedir memoria
dinmica, etc. El destructor no se debe llamar explcitamente, 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 (parmetros);

Si hemos reservado memoria dinmica en la funcin constructora, podemos aprovechar y

liberarla en la destructora.
PUNTERO THIS

Variable predefinida para todas las funciones miembros de

la clase. (parmetro oculto)

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

est aplicando el mtodo. (No es el objeto)

En la invocacin de una funcin miembro, el objeto es un

parmetro implcito.
PUNTERO THIS

El puntero this contiene la direccin del objeto que activ al

mtodo y NO es posible modificarlo.

Al recibir el parmetro implcito, puede referenciar

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

Un mtodo 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 mtodo 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 nmeros 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 funcin sobrecargada es:

tipo_a_devolver nombre_clase::operator(parmetros);
SOBRECARGA DE OPERADORES
Operaciones aritmticas 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 aritmtico (? :)
Operador sizeof
Operador de resolucin de alcance (::)
Puntero a un miembro de un objeto (*.)
RESTRICCIONES

Se
puede modificar la definicin de un
operador, pero NO su gramtica (nmero 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 implcito

(izquierda del operador)
Requiere que el primer operando de la funcin
sea un objeto de la clase (izquierda del operador)
Contiene slo UN parmetro

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

Funcin "Amiga" de la clase

Operador acta sobre varios objetos SIN
modificarlos
Primer parmetro (objeto de la izquierda). Ahora
explcito
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
RELACIN
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
ASIGNACIN
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 asignacin
Protege contra la "auto-asignacin"
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 DINMICAS

La implementacin de este operador ser ms

interesante cuando el objeto posea variables
dinmicas:

f:
p: num: 2
den: 3
Mtodos
 SOBRECARGA DE
OPERADORES
<< - >>
cout <<f;
cout<<"la fraccin 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 mtodo retorne la direccin del objeto para
que se pueda utilizar varias veces en una expresin
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 fraccin es:"<<f;
cout<<"La suma de"<<f<<" y" <<g<<"es:"<<h;
COMPOSICIN
DE
CLASES
COMPOSICIN DE CLASES

Relacin 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];
};
COMPOSICIN 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 implcitamente 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); annimo
Invocacin
cin.getline(cod,7); explcita 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();
}
COMPOSICIN DE CLASES

class Fecha class Empleado objetos

{private: {private: de
int dia; char *nom; clase
int mes; char *app; Fecha
int ao; 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();
}
Composicin 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)
debern inicializarse aquellos datos que sean
objetos de otras clases, por medio, de sus
constructores.
COMPOSICIN 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 mtodos
} de la clase Fecha
USO DE LA CLASE EMPLEADO

#include "empldef.h"

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

Mecanismo para implementar funciones genricas

template <classT>
tipo nombre(parmetros)
{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:
genricas

template<class T>
class nombre
{private:
Mtodos
Variables
public:
Mtodos
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();
};
MTODOS

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 GENRICAS

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