PROGRAMACIÓN ORIENTADA A OBJETOS

Ing. Betty Suárez Torres

CONCEPTOS BÁSICOS DE CLASES

Una clase es un medio para empaquetar los Tipos de Datos Abstractos (TDA) y permite que tanto los elementos de datos como las rutinas de acceso de un Tipo de Datos Abstracto se encapsulen juntos en una misma entidad.

Un objeto es una materialización o realización de una clase. Cada objeto contiene su propio conjunto de elementos de datos denominados variables miembro o datos miembro.

Tanto los miembros como las variables de clase se empaquetan tal que sólo puedan se accedidos por la rutinas determinadas por la clase. Las rutinas de una clase son comunes a todos los objetos de la clase, y se denominan funciones miembro.

CLASES: FUNCIONES O MÉTODOS

Los procedimientos y funciones definidos dentro de una clase se llaman métodos grupo de instrucciones asociadas en una clase de objetos que actúan en si mismos y en otras clases y objetos. Hacen tareas específicas y en otros lenguajes se llaman funciones.

nombre de clase

atributos

operaciones / métodos

nombre de clase

atributos

operaciones / métodos

CLASES: SINTAXIS

• DECLARACIÓN DE UNA CLASE

class nombre_clase{

var1;

var2;

…

public:

metodos / funciones / operaciones;

};

#include <stdio.h>#include <conio.h>class rectangulo{ float longitud; float altura;public: rectangulo(float l, float a); double perimetro(); double area();};rectangulo::rectangulo(float l, float a){ longitud=l; altura=a; }double rectangulo::perimetro(){return 2*(longitud+altura); }

double rectangulo::area(){

return longitud*altura;}void main(){ float l,a; printf("Ingresar longitud:"); scanf("%f",&l); printf("Ingresar altura:"); scanf("%f",&a); rectangulo x(l,a); printf("Perimetro= %10.2lf\n",x.perimetro()); printf("Area= %10.2lf\n",x.area()); getch(); }

HALLAR EL PERÍMETRO Y ÁREA DE UN RECTÁNGULO

class Empleado { private: char* m_nombre; char* m_departamento; char* m_cargo; float m_salario; public: void Imprimir(); void SetNombre( char* nombre ) { m_nombre = nombre; } void SetDepartamento( char * departamento) { m_departamento = departamento; } void SetCargo ( char* cargo ) { m_cargo = cargo; } void SetSalario ( long salario ) { m_salario = salario; } const char* GetNombre( ){ return m_nombre; } const char* GetDepartamento( ){ return m_departamento; } const char* GetCargo( ){ return m_cargo; } const float GetSalario( ){ return m_salario; }};

DISEÑAR LA CLASE EMPLEADO CON LOS SIGUIENTES DATOS:NOMBRE, DIRECCIÓN, CARGO O PUESTO QUE DESEMPEÑA, SALARIO

void Empleado::ImprimirInfo( ) {

cout << "Nombre: " << m_nombre << '\n';

cout << "Departamento: " << m_departamento << '\n';

cout << "Puesto: " << m_cargo << '\n';

cout << "Salario: " << m_salario << '\n';

getch(); }

void main() {

Empleado empleado12;

empleado12.SetNombre("Jose");

empleado12.SetDepartamento("Sistemas");

empleado12.SetCargo("Programador");

empleado12.SetSalario(3000);

//impresion de los datos

empleado12.Imprimir();

}

DISEÑAR LA CLASE EMPLEADO EN DONDE SE MUESTRE INFORMACIÓN DE PERSONAS NATURALES Y JURÍDICAS

#include <iostream>#include <conio.h>

using namespace std;

class Persona {char *nombres;char *apellidos;char *direccion;char *telefono;public:void Setnombres( char n[50]) { nombres=n; }void Setapellidos(char p[50]) { apellidos=p; }void Setdireccion( char d[50]) { direccion=d; }void Settelefono(char t[50]) { telefono=t; }void Imprimir();};

//clase derivadaclass Empresa:public Persona {char* razonsocial;char* ciudad;char* email;public:void Setrazonsocial( char* r) { razonsocial=r; }void Setciudad( char* c) { ciudad=c; }void Setemail( char* e) { email=e; }void Imprimir();};

void Persona::Imprimir(){cout<<"\nDatos persona natural"<<endl;cout<<"Nombres: "<<nombres<<"\n";cout<<"Apellidos: "<<apellidos<<"\n";cout<<"Direccion: "<<direccion<<"\n";cout<<"Teléfono: "<<telefono<<"\n";}

void Empresa::Imprimir(){cout<<"\nDatos persona juridica"<<endl;Persona::Imprimir();cout<<"Nombre de empresa: "<<razonsocial<<"\n";cout<<"Ciudad: " << ciudad<<"\n";cout<<"E-mail: " << email<<"\n";}

void ingresar(){char nom[50], ape[50], dir[50],

tel[50];Persona empInfo1; cout<<"Nombres: ";

cin>>nom;cout<<"Apellidos: "; cin>>ape;cout<<"Dirección: "; cin>>dir;cout<<"Teléfono: "; cin>>tel;empInfo1.Setnombres(nom);empInfo1.Setapellidos(ape);empInfo1.Setdireccion(dir);empInfo1.Settelefono(tel);empInfo1.Imprimir();

}

void ingresare(){char nome[50], apee[50], dire[50], tele[50], raze[50], ciue[50], eme[50];Empresa empInfo2;cout<<"Nombres: "; cin>>nome;cout<<"Apellidos: "; cin>>apee;cout<<"Dirección: "; cin>>dire;cout<<"Teléfono: "; cin>>tele;cout<<"Razón social: "; cin>>raze;cout<<"Ciudad: "; cin>>ciue;cout<<"E-mail: "; cin>>eme;empInfo2.Setnombres(nome);empInfo2.Setapellidos(apee);empInfo2.Setdireccion(dire);empInfo2.Settelefono(tele);empInfo2.Setrazonsocial(raze);empInfo2.Setciudad(ciue);empInfo2.Setemail(eme);empInfo2.Imprimir();}

void main(){ int op; cout<<"1. Persona natural\n"; cout<<"2. Persona jurídica\n"; cout<<"3. Salir\n"; cout<<"Ingresar opción: ";cin>>op;switch(op){ case 1:

ingresar();break; case 2:

ingresare();break; case 3:

exit(0);}getch();}

CONCEPTOS BÁSICOS DE ESTRUCTURAS

• Una estructura es una colección de uno o más tipos de elementos denominados miembros, cada uno de los cuales puede ser un tipo de dato diferente.

• Una estructura puede contener cualquier número de miembros, cada uno de los cuales tiene un nombre único, denominado nombre del miembro. Supongamos que se desea almacenar los datos de una colección de discos compactos (CD) de música. Estos datos pueden ser:

Título Array de caracteres tamaño 30

Artista Array de caracteres tamaño 25

Número de canciones Entero

Precio Coma flotante

Fecha compra Array de caracteres tamaño 8

DECLARACIÓN DE UNA ESTRUCTURA

struct nombre_estructura{

<tipo de dato miembro > <nombre miembro>

<tipo de dato miembro> <nombre miembro>

<tipo de dato miembro> <nombre miembro>

...

} ;

Ejemplo: para declarar la estructura CD la sintaxis de declaración es:

struct colección_CD{

char titulo[30] ;

char artista[25] ;

int num_canciones;

float precio;

char fecha_compra[8]; };

USO DE ESTRUCTURAS

/ * declarar una estructura Persona * /

struct persona{

char nombre [30 I ;

int edad;

float altura;

float peso;

} ;

void main( ){

struct persona mar;

printf ("Sizeof( persona): %d \n",s izeof (mar)) ;

}

Al ejecutar el programa se produce la salida: Sizeof (persona) : 40

USO DE ESTRUCTURAS …

El operador sizeof se aplica sobre un tipo de datos, o bien sobre una variable. Se puede aplicar para determinar el tamaño que ocupa en memoria una estructura.

Persona Miembros dato Tamaño (bytes)

nombre[20] char(1) 30

edad int(2) 2

altura float(4) 4

peso float(4) 4

Total 40

struct vector{

float x;

float y;

};

void main(){

struct vector p1, p2; //p1={1,2},p2={3,4}

float distancia;

cout<<"Introduzca valor del primer punto x: ";cin>>p1.x;

cout<<"Introduzca valor del segundo punto x: ";cin>>p2.x;

cout<<"Introduzca valor del primer punto y: ";cin>>p1.y;

cout<<"Introduzca valor del segundo punto y: ";cin>>p2.y;

distancia=sqrt(pow(p2.x-p1.x,2)+pow(p2.y-p1.y,2));

cout<<"Distancia es: "<<distancia;

getch();

}

Estructura que dadas dos personas mostrar quien es mayor

struct persona{

char nombre[50];

int edad;

};

void main(){

struct persona p1;

struct persona p2;

struct persona p;

printf("Ingresar nombre primera persona: ");

gets(p1.nombre);

printf("Ingresar edad primera persona: ");scanf("%d",&p1.edad);fflush(stdin);printf("Ingresar nombre primera persona: ");gets(p2.nombre);printf("Ingresar edad primera persona: ");scanf("%d",&p2.edad);fflush(stdin);if(p2.edad>p1.edad)

p=p2;else

p=p1;printf("Nombre del mayor: %s\n",p.nombre);printf("Edad del mayor: %d",p.edad);getch(); }

ESTRUCTURAS ANIDADAS

Una estructura puede contener otras estructuras llamadas estructuras anidadas.

Las estructuras anidadas ahorran tiempo en la escritura de programas que utilizan estructuras similares. Se han de definir los miembros comunes sólo una vez en su propia estructura y a continuación utilizar esa estructura como un miembro de otra estructura.

EJEMPLO DE ESTRUCTURA ANIDADAS

struct empleado{

char nombre_emp[30];

char direccion[25] ;

char ciudad[20];

char provincia[20] ;

long int cod_postal;

double salario;

};

struct clientes char nombre_cliente[30]; char direccion[25]; char ciudad[20]; char provincia[20]; long int cod_postal; double saldo;};

EJEMPLO DE UNA ESTRUCTURA QUE PUEDE SER LLAMADA DESDE OTRA

struct info_dir{

char direccion[25] ;

char ciudad[20];

char provincia[20] ;

long int cod_postal;

};

Esta estructura se puede utilizar como un miembro de las otras estructuras, es decir, anidarse.

struct empleado{

char nombre_emp[30];

struct info_dir direccion_emp;

double salario;

} ;

struct clientes{char nombre_cliente[30];struct info_dir direccion_clien;double saldo;};

#include <stdio.h>#include <conio.h>struct fecha{

unsigned int dia, mes, anyo;};struct persona{

char nombre[20];unsigned int edad;float altura;float peso;struct fecha fec;

};struct persona_empleado{

struct persona persona1;unsigned float salario;unsigned int horas_por_semana;

};

void entrada(struct persona_empleado *p);void muestra(struct persona_empleado up);

void main(){//define una variable persona_empleadostruct persona_empleado p;

entrada(&p);

muestra(p);getch();}

void entrada(struct persona_empleado *p){

printf("\nIntroduzca su nombre: ") ; gets(p->persona1.nombre);

printf("introduzca su edad: "); scanf("%d", &p->persona1.edad) ;

printf("Introduzca su altura: ") ; scanf("%f", &p->persona1.altura) ;

printf("Introduzca su peso: "); scanf("%f", &p->persona1.peso) ;

printf("Introduzca su fecha de nacimiento: " ) ; scanf("%d %d %d", &p->persona1.fec.dia, &p->persona1.fec.mes, &p->persona1.fec.anyo);

printf("Introduzca su salario:"); scanf("%f", &p->salario);

printf("introduzca numero de horas:"); scanf("%d", &p->horas_por_semana) ;

}

void muestra(struct persona_empleado p1){

printf("\n\n\t Datos de un empleado\n");

printf("Nombre: %s \n",p1.persona1.nombre);

printf("Edad: %d \n",p1.persona1.edad);

printf("fecha de nacimiento: %d/%d/%d\n",

p1.persona1.fec.dia,

p1.persona1.fec.mes,

p1.persona1.fec.anyo);

printf("A1tura: %f \n", p1.persona1.altura) ;

printf("Peso: %f \n", p1.persona1.peso);

printf("Numero de horas: %d \n", p1.horas_por_semana);

}

Una librería desea catalogar su inventario de libros. El siguiente programa crea un array de 100 estructuras, donde cada estructura contiene diversos tipos de variables, incluyendo arrays.

#include <stdio.h>

#include <conio.h>

#include <ctype.h>

struct inventario{

char titulo[25];

char fecha_pub[20];

char autor[30];

int num;

int pedido;

int precio_venta;

};

void main(){

struct inventario libro[100];

int total=0;

char resp;

do{

printf ("Número de libro: %d", (total+1));

printf("\n¿Cuál es el título?: ");

gets(libro[total].titulo) ;

fflush(stdin);

printf("Cuá1 es la fecha de publicación?: ") ;

gets(libro[total].fecha_pub);

printf ("¿Quién es el autor?");

gets(libro[total].autor);

printf("¿Cuántos libros existen?: "); scanf ("%d",&libro[total].num);

printf("¿Cuántos ejemplares existen pedidos?: "); scanf("%d",&libro[total].pedido);

printf("¿Cuál es el precio de venta?: "); scanf("%d",&libro[total].precio_venta);

fflush(stdin);

printf("\n ¿Hay más libros? (S/N)"); scanf("%c",&resp);

fflush(stdin);

resp=toupper(resp);

if(resp=='S'){

total++;

continue ;

}

}while(resp=='S');

getch(); }