Documenti di Didattica
Documenti di Professioni
Documenti di Cultura
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>
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:
private:
Todos los atributos;
Mtodos internos que manejan memoria
public:
Mtodos que manipulan lo declarado en la parte private;};
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 clase a partir de la cual, los objetos son producidos. Se
trata, pues, de una programacin orientada al objeto.
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:
# include <iostream.h>
main( )
{
cout <<'' Bienvenido a C++! \n'';
return 0;
}
Todas las palabras claves de C++ estn en minsculas. En C++, las maysculas y minsculas son
diferentes
C++ nicamente
template Declara cmo construir una clase o una funcin, usando una variedad de
tipos.
* 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 : /* */.
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.
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.
dec = %d (enteros)
hex = hexadecimal
oct = octal
cout<<setw(6)<<variable
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);
*this
PUNTERO THIS
1. tope = -1;
2. this->tope = -1;
3. (*this).tope = -1
SOBRECARGA
DE
OPERADORES
SOBRECARGA DE OPERADORES
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:
Se
puede modificar la definicin de un
operador, pero NO su gramtica (nmero de
operandos, precedencia y asociatividad)
Es
el tipo de operandos lo que determina qu
operador utilizar.
EL OPERADOR SOBRECARGADO:
1. Operador Miembro
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
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
2. Operador Friend
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
a) if (f1==f2)
b) x= (f1==f2);
SOBRECARGA DEL
OPERADOR DE
ASIGNACIN
EJEMPLO: SOBRECARGAR =
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
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: << - >>
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.
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
Alumno::Alumno()
{k=0; t=0;}
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
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
template <classT>
tipo nombre(parmetros)
{sentencias}
EJEMPLO
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
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
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