Anda di halaman 1dari 28

13° CLASE

Informática II
Ingeniería Electrónica

Tema:
Clases
Constructores
Destructores
MODIFICACIONES MAYORES
La Programación Orientada a Objetos (POO) permite realizar grandes programas
mediante la unión de elementos más simples, que pueden ser diseñados y comprobados
de manera independiente del programa que va a usarlos.

En C++ un programa consta de objetos.


Los objetos son como los tipos abstractos de datos:

• Son un tipo de datos definido por el programador junto con un conjunto


de operaciones que se pueden realizar sobre ellos.

• Son abstractos para diferenciarlos de los tipos de datos básicos definidos,


por ejemplo int, char y double.

OBJETOS: Entidad compuesta por datos y operaciones que se


realizan sobre esos datos.

Un objeto esta compuesto por:


- Datos A los elementos
- Funciones de un objeto se
los conoce como
miembros
CLASES
El lenguaje C++ entiende por clase un tipo de dato definido por el programador
que contiene toda la información necesaria para construir un objeto de dicho tipo
y el conjunto de operaciones que permiten manejarlo (métodos).

Un objeto es una unidad que


contiene datos y las funciones
que operan sobre esos datos.

A los elementos de un
objeto se los conoce
como miembros

A las funciones que operan sobre los objetos se denominan métodos ó


funciones miembro y los datos se denominan miembros datos ó
atributos.
La definición de una clase consta de dos partes: una declaración y una
implementación.

La declaración lista
los miembros de la clase.

La implementación o cuerpo define


las funciones de la clase.

Cuando una función miembro se define por fuera de la definición de clase, el nombre
de la función es antecedido por el nombre de la clase y por el operador de resolución.
INSTANCIAS DE UNA CLASE
// Ejemplo de clases
Podemos acceder
#include <iostream> directamente a los
atributos por que
using namespace std; son públicos
int main()
class persona{ {
public: cout << "nombre? ";
char nombre[30]; public: cin >> c.nombre;
char calle [30]; cout << "edad? ";
double importe_factura; cin >> c.edad;
char tif[20];
int edad; cout << "\nNombre: “ << c.nombre;
} cout << "\nEdad: "<< c.edad << “ \n\n";
return 0;
}
Se instancia una
clase persona
El siguiente ejemplo muestra la implementación de la función Asignar() dentro de la
clase, y la función Calcular() mediante una implementación independiente.

/*Clase2.cpp */ void main()


#include <string.h> { system(cls);
#include <conio.h> Empleado E;
#include <iostream.h> E.Asignar("Juan Pérez",120);
#include<stdlib.h> E.Calcular();
}
using namespace std;

class Empleado{
char Nom[40];
float Salario;

public:
//implementación dentro de la clase La salida del programa es:
void Asignar(char *N,float S) { El salario Semanal de: Juan Pérez :840
strcpy(Nom,N);
Salario=S;}
void Calcular();
};

//Implementación independiente
void Empleado::Calcular()
{ float S;
S=Salario*7;
cout<<"El salario Semanal de: "<<Nom<<" :"<<S;
Constructores
Los constructores son funciones miembro especiales que sirven para inicializar
un objeto de una determinada clase cuando se declara.

Se caracteriza por:
- Los constructores tienen el mismo nombre que la clase.
- No retornan ningún valor y no pueden ser heredados.
- Puede existir mas de un constructor, e incluso no existir.
- Además deben ser públicos.
/*Const.cpp */
#include <string.h>
#include <conio.h>
#include <iostream.h>

class Producto{
char *Nom;
int Cantidad;
float Precio;
public:
Producto(); //Primer Constructor
Producto(char *N,int C,int P); //Segundo constructor
void Ver();
};
//Implementación de funciones miembros
Producto::Producto() void main()
{
{
Nom=new char[50]; clrscr();
strcpy(Nom,"Ninguno");
Producto P,Pro("Disco Duro 20 GBytes",4,1600);
Cantidad=0;
Pro.Ver();
Precio=0; P.Ver();
}
getch(); Si una clase posee constructor, será
} llamado siempre que se declare un objeto
Producto::Producto(char *N,int C,int P)
{ int L; de esa clase, y si requiere argumentos,
L=strlen(N); es obligatorio suministrarlos.
Nom=new char[L];
strcpy(Nom,N); La salida del programa es:
Cantidad=C;
Precio=P; Disco Duro 20 Gbytes
} 4
1600
void Producto::Ver() Ninguno
{ 0
cout<<"\n"<<Nom; 0
cout<<"\n"<<Cantidad;
cout<<"\n"<<Precio; Para declarar objetos usando el constructor por defecto o un
} constructor que hayamos declarado sin parámetros no se
debe usar el paréntesis:
Producto P(); // Error
Producto P; // Uso correcto
Destructores
Los destructores son funciones miembro especiales que sirven para eliminar un
objeto de una determinada clase, liberando la memoria utilizada por dicho objeto.

Las funciones destructores tienen las siguientes características:

• Tiene el mismo nombre que la clase, precedido por una tilde (∼)
• No retorna ningún valor
• No tiene parámetros
• Una clase solamente puede tener como máximo un destructor.
• Se llama automáticamente por el compilador cuando el objeto sale de ámbito.

/*Const2.cpp */
class Producto{ El programa puede funcionar
char *Nom; con el resto del código sin
int Cantidad; ningún problema por que el
float Precio; destructor no se debe llamar en
public: ninguna parte del programa,
Producto(); //Primer Constructor más bien el compilador lo llama
Producto(char *N,int C,int P); //Segundo constructor en forma automática cuando
void Ver(); los objetos P y Pro salen de
~Producto(){delete (Nom);} //Destructor ámbito, es decir cuando finaliza
}; la función main()
Programa para dibujar rectángulos en modo texto.
void Rect::Dibujar() // Implementación
/*Rectang.cpp */ // independiente
#include <windows.h> { int x,y;
#include <conio.h> for (x=x1;x<x2;x++)
#include <iostream> {
gotoxy(x,y1);cout << "Ä";
using namespace std; gotoxy(x,y2);cout<<"Ä";
}
class Rect{ for (y=y1+1;y<y2;y++)
int x1,y1,x2,y2; {
public: gotoxy(x1,y);cout<<"3";
Rect() //Constructor gotoxy(x2,y);cout<<"3";
{x1=35;y1=10;x2=45;y2=14;} }
void Dibujar(); gotoxy(x1,y1);cout<<"Ú";
void Asignar(int x,int y,int j,int k) gotoxy(x2,y1);cout<<"¿";
{x1=x;y1=y;x2=j; y2=k;} gotoxy(x1,y2);cout<<"À";
}; gotoxy(x2,y2);cout<<"Ù";
}
void gotoxy(int x,int y){
HANDLE hcon; int main()
hcon = GetStdHandle(STD_OUTPUT_HANDLE); { system("cls");
COORD dwPos; Rect R; //Se crea un objeto
dwPos.X = x; R.Dibujar(); //se dibuja c/ valores
dwPos.Y= y; // por defecto
SetConsoleCursorPosition(hcon,dwPos); R.Asignar(30,8,50,16);
} R.Dibujar();
getch();
}
Escribir un programa que maneje una clase Hora con datos miembros tales como horas,
minutos y segundos y funciones para la asignación visualización de los datos, deberá contar
con dos constructores.
/*Hora.cpp*/
#include <windows.h> void Hora::Asigna()
#include <iostream.h> {
#include <conio.h> cout<<"\nHora: ";
using namespace std; cin>>Hra;
class Hora{ cout<<"Minutos: ";
int Hra; cin>>Min;
int Min; cout<<"Segundos: ";
int Seg; cin>>Seg;
public: }
Hora() {Hra=0;Min=0;Seg=0;} //Primer Constructor
Hora(int H,int M,int S); //Segundo constructor
void Asigna(); void Hora::Ver()
void Ver(); {
}; cout<<"\nLa hora es: "<<Hra<<":"<<Min<<":"<<Seg;
}
//Implementación de
//funciones miembros void main() { //Función principal
system("cls");
Hora::Hora(int H,int M,int S) Hora H(9,14,10); //Creación de un objeto
{ H.Ver();
Hra=H; H.Asigna();
Min=M; H.Ver();
Seg=S; getch();
} }