Documenti di Didattica
Documenti di Professioni
Documenti di Cultura
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>
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:
private:
Todos los atributos;
Métodos internos que manejan memoria
public:
Métodos 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 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 clase a partir de la cual, los objetos son producidos. Se
trata, pues, de una programación orientada al objeto.
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:
# include <iostream.h>
main( )
{
cout <<''¡ Bienvenido a C++! \n'';
return 0;
}
Todas las palabras claves de C++ están en minúsculas. En C++, las mayúsculas y minúsculas son
diferentes
C++ únicamente
template Declara cómo construir una clase o una función, usando una variedad de
tipos.
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.
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.
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, 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);
*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(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:
Se
puede modificar la definición de un
operador, pero NO su gramática (número 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
ASIGNACIÓN
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 asignación
Protege contra la "auto-asignación"
Elimina posibles elementos antiguos
Inicializa y copia los nuevos elementos
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: << - >>
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.
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
Alumno::Alumno()
{k=0; t=0;}
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
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
template <classT>
tipo nombre(parámetros)
{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:
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
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