UNIVERSIDAD AUTONOMA “JUAN MISAEL SARACHO”
FACULTAD DE CIENCIAS Y TECNOLOGIA
CARRERA DE INGENIERIA INFORMÁTICA
º
GUÍA DE LABORATORIO 1
MATERIA: Programación III
GRUPO: 3
FECHA:19 /03/24
OBJETIVOS:
Describir la estructura de una clase en C++
Escribir programas que hagan uso de clases en C++
TEORÍA:
1.- CLASE
En programación orientada a objetos (POO), una clase es una plantilla que define las
propiedades (atributos) y el comportamiento (métodos) de los objetos que se crean a
partir de esa clase.
Una clase es una abstracción de un conjunto de objetos similares que permite crear
o instanciar diferentes objetos de esa clase, cada instancia se crea para contener datos
particulares de ese objeto. Por ejemplo, en el sistema Tariquía, la clase Estudiante
tendrá atributos como: nombre, CI, fecha de nacimiento, etc., y métodos como
programarMaterias(), verCalificaciones(), requerirCertificado(), etc. Cuando se creen
instancias de la clase Estudiante, cada una contendrá los datos de un estudiante en
particular.
De una forma simple podemos decir que una clase es un MODELO donde se redactan
las características comunes de un grupo de objetos.
2.- OBJETO E INSTANCIA, es un ejemplar perteneciente a una clase, los objetos
pueden tener propiedades(características) y métodos (comportamientos), es decir
características.
3.- IMPLEMENTACION DE CLASES EN C++
Para implementar clases en C++, se usa la siguiente sintaxis:
class nombre {
especificador_de_acceso_1:
miembro1;
miembro2;
...
miembroN;
especificador_de_acceso_2:
1
UNIVERSIDAD AUTONOMA “JUAN MISAEL SARACHO”
FACULTAD DE CIENCIAS Y TECNOLOGIA
CARRERA DE INGENIERIA INFORMÁTICA
º
miembroN+1;
...
miembroM;
};
Donde los miembros de la clase pueden ser atributos o métodos. Los atributos pueden
ser de cualquier tipo, estructura de datos o clase.
Dos de los métodos muy importantes son el constructor y destructor. El método
constructor se usa al momento de crear una instancia, mientras que el método destructor
se usa cuando se libera la memoria usada por el objeto. Si no se definen estos métodos,
el compilador generará ambos constructores por defecto, los que se invocan
automáticamente.
El especificador o métodos de acceso puede ser uno de los siguientes:
private: los miembros privados son accesibles solamente desde el interior de la
clase, solo los otros miembros pueden verlos y usarlos.
protected: los miembros protegidos únicamente pueden ser visibles por los demás
miembros de la clase y de sus clases hijas o derivadas.
public: los miembros públicos son totalmente accesibles desde el interior y exterior
de la clase, donde el objeto sea visible.
Por defecto, los miembros que no constan de especificador de acceso, son privados.
Las buenas prácticas de programación recomiendan que los atributos de las clases sean
privados, lo que tiene varios beneficios, principalmente porque se aplica el principio de la
POO denominada: encapsulación; evita accesos no permitidos y mejora el
mantenimiento y escalamiento. Cuando es necesario que desde el exterior de la clase se
modifiquen los atributos privados, se disponen métodos públicos denominados getter y
setter que permiten obtener y modificar los atributos.
Los métodos generalmente son públicos, pero en ocasiones conviene que sean privados,
particularmente cuando esos métodos solo deben ser usados desde el interior de la clase.
En un programa, una clase puede ser definida antes de la función main(), o bien ser
definida en un archivo independiente.
Ejemplo 1.
Para ilustrar, a continuación se escribe la clase estudiante, con los atributos privados:
string nombre, string CI e int RU y los métodos: constructor, e imprimir() que lleva los
valores de los atributos a la pantalla; luego se crean dos instancias de la clase estudiante
y se llama al método imprimir() para visualizar sus datos.
#include <iostream>
#include <string>
using namespace std;
class Estudiante {
2
UNIVERSIDAD AUTONOMA “JUAN MISAEL SARACHO”
FACULTAD DE CIENCIAS Y TECNOLOGIA
CARRERA DE INGENIERIA INFORMÁTICA
º
private:
string nombre;
string CI;
int RU;
int Edad;
public:
Estudiante(string n, string ci, int ru, int edad) {
nombre = n;
CI = ci;
RU = ru;
Edad = edad;
}
void imprimir(){
cout << "Nombre: " << nombre << endl;
cout << "CI: " << CI << endl;
cout << "RU: " << RU << endl;
cout << "Edad: " << Edad << endl;
}
};
int main() {
// Crear dos objetos Estudiante
Estudiante estudiante1("Carlos Romero Arce", "345678", 1001,19);
Estudiante estudiante2("Simon Rodriguez Castro", "854321", 1002,20);
cout << "Estudiante 1:" << endl;
[Link]();
cout << "\nEstudiante 2:" << endl;
[Link]();
return 0;
}
Una mejor forma de definir una clase es en un archivo independiente
3
UNIVERSIDAD AUTONOMA “JUAN MISAEL SARACHO”
FACULTAD DE CIENCIAS Y TECNOLOGIA
CARRERA DE INGENIERIA INFORMÁTICA
º
Archivo correspondiente a la clase: [Link]
#include <iostream>
#include <string>
using namespace std;
class Estudiante {
private:
string nombre;
string CI;
int RU;
int Edad;
public:
Estudiante(string n, string ci, int ru, int edad) {
nombre = n;
CI = ci;
RU = ru;
Edad = edad;
}
void imprimir(){
cout << "Nombre: " << nombre << endl;
cout << "CI: " << CI << endl;
cout << "RU: " << RU << endl;
cout << "Edad: " << Edad << endl;
}
};
Archivo correspondiente al programa con la función principal:
#include <iostream>
#include "[Link]"
using namespace std;
int main() {
// Crear dos objetos Estudiante
Estudiante estudiante1("Carlos Romero Arce", "345678", 1001,19);
Estudiante estudiante2("Simon Rodriguez Castro", "854321", 1002,20);
cout << "Estudiante 1:" << endl;
[Link]();
cout << "\nEstudiante 2:" << endl;
[Link]();
return 0;
}
4
UNIVERSIDAD AUTONOMA “JUAN MISAEL SARACHO”
FACULTAD DE CIENCIAS Y TECNOLOGIA
CARRERA DE INGENIERIA INFORMÁTICA
º
Una tercera forma de crear clases, con mayores ventajas que en los casos anteriores,
principalmente cuando se desarrollan proyectos grandes, es con un archivo de cabecera
(.h), que contiene la definición de la clase con sus atributos y encabezados de sus
métodos, el que deberá ser importado por la clase con el método principal. La
implementación de los métodos va en un archivo separado. Por ejemplo:
Archivo de cabecera: Estudiante.h:
#ifndef ESTUDIANTE_H
#define ESTUDIANTE_H
#include <string>
using namespace std;
class Estudiante {
private:
string nombre;
string CI;
int RU;
public:
Estudiante(string n, string ci, int ru);
void imprimir();
};
#endif // ESTUDIANTE_H
Archivo de implementación: [Link]:
#include "Estudiante.h"
#include <iostream>
using namespace std;
Estudiante::Estudiante(string n, string ci, int ru) {
nombre = n;
CI = ci;
RU = ru;
}
void Estudiante::imprimir() {
cout << "Nombre: " << nombre << endl;
cout << "CI: " << CI << endl;
cout << "RU: " << RU << endl;
}
Archivo con el método principal: [Link]
#include <iostream>
#include "Estudiante.h"
using namespace std;
int main() {
5
UNIVERSIDAD AUTONOMA “JUAN MISAEL SARACHO”
FACULTAD DE CIENCIAS Y TECNOLOGIA
CARRERA DE INGENIERIA INFORMÁTICA
º
Estudiante estudiante1("Antonela Santos Pacheco",
"12345678", 1001);
Estudiante estudiante2("Juan Alberto Tapia Pereira",
"87654321", 1002);
cout << "Estudiante 1:" << endl;
[Link]();
cout << "\nEstudiante 2:" << endl;
[Link]();
return 0;
}
4.- METODO CONSTRUCTOR
El constructor es un método especial que tiene el mismo nombre de la clase y se llama
cuando se crea o instancia un objeto de una clase, su función es inicializar los atributos
y establecer el estado inicial del objeto.
Si el programador no define el método constructor, entonces el compilador proporciona
un método constructor implícito sin parámetros.
El método constructor definido por el programador puede tener cero o más parámetros
formales, que permiten inicializar a los atributos miembros de la forma:
nombreClase(tipo1 var1, tipo2 var2, …){
atrib1=var1;
atrib2=var2;
…
}
Otra forma de inicializar los atributos mediante el método constructor es usar una lista de
inicialización, cuya sintaxis es:
constructor(tipo1 var1, tip2 var2, …): atrib1(var1), atrib2(var2), …{}
El método constructor siempre actúa al instanciar un objeto y el método destructor cuando
deja de tener vigencia un objeto en el stack o cuando se elimina explícitamente el objeto
en el heap.
#include <iostream>
using namespace std;
class MiClase {
public:
MiClase() {
cout << "Constructor llamado!" << endl;
6
UNIVERSIDAD AUTONOMA “JUAN MISAEL SARACHO”
FACULTAD DE CIENCIAS Y TECNOLOGIA
CARRERA DE INGENIERIA INFORMÁTICA
º
}
};
int main() {
MiClase miObjeto; // El constructor se llama aquí
return 0;
}
5.- METODO DESTRUCTOR
El método destructor, que también lleva el nombre de la clase, precedido por el símbolo
de virgulilla (~), es el encargado de liberar la memoria usada por el objeto; si no se define,
el compilador genera un método destructor por defecto que se usa automáticamente si el
objeto ha sido creado en el stack; por otra parte, si el objeto se crea en el heap, es
fundamental definir explícitamente el método destructor pues la liberación de memoria no
es automática. En el siguiente ejemplo se añadió el método destructor para apreciar su
comportamiento.
#include <iostream>
using namespace std;
class MiClase {
public:
// Constructor
MiClase() {
cout << "Constructor llamado!" << endl;
}
// Destructor
~MiClase() {
cout << "Destructor llamado!" << endl;
}
};
int main() {
MiClase objeto1; // el constructor se llama aquí
MiClase* objeto2=new MiClase; // constructor invocado
delete objeto2; //el destructor del objeto2 se invoca aquí.
return 0; // El destructor del objeto1 se invoca aquí
}
El acceso a los miembros (atributos y métodos públicos) del objeto: obj de una clase, se
realiza con una de las dos notaciones siguientes:
[Link] o [Link](); cuando obj es un identificador definido en el stack.
obj->atributo u obj->método(); cuando obj es un puntero que apunta a un objeto,
generalmente en el heap.
Donde el símbolo -> es una abreviación más compacta de las operaciones: desreferencia
y de acceso a miembros: * y .
Se denomina sobrecarga de métodos cuando se definen dos o más métodos con el
mismo nombre, pero diferente número o tipo de parámetros; esta característica es muy
útil para escribir código legible, flexible y coherente.
7
UNIVERSIDAD AUTONOMA “JUAN MISAEL SARACHO”
FACULTAD DE CIENCIAS Y TECNOLOGIA
CARRERA DE INGENIERIA INFORMÁTICA
º
EJEMPLOS:
Ejemplo1
Escribir la clase: Rectangulo que tenga los atributos reales: lado1 y lado2 y los métodos
constructor con ambos parámetros y el método area() que devuelva el área del
rectángulo; posteriormente escribir la función principal que crea una instancie de la clase
Rectangulo con dos parámetros e imprima el área del mismo.
#include <iostream>
using namespace std;
class Rectangulo {
private:
double lado1;
double lado2;
public:
Rectangulo(double lado1, double lado2) {
this->lado1 = lado1;
this->lado2 = lado2;
}
double area() {
return lado1 * lado2;
}
~Rectangulo(){};
};
int main() {
Rectangulo rect(5.0, 3.0);
cout << "El área del rectángulo es: " << [Link]() << endl;
return 0;
}
Es usual usar los parámetros del método de constructor como una lista de inicialización:
Rectangulo(double lado1, double lado2) : lado1(lado1),
lado2(lado2) {}
Ejemplo2
Repetir el ejemplo anterior añadiendo a la clase los métodos públicos getter y setter y
usarlos para asignar y recuperar los datos.
#include <iostream>
using namespace std;
class Rectangulo {
private:
double lado1;
double lado2;
8
UNIVERSIDAD AUTONOMA “JUAN MISAEL SARACHO”
FACULTAD DE CIENCIAS Y TECNOLOGIA
CARRERA DE INGENIERIA INFORMÁTICA
º
public:
Rectangulo(double lado1, double lado2):lado1(lado1),
lado2(lado2) {}
double area() {
return lado1 * lado2;
}
void setLado1(double lado1) { this->lado1 = lado1; }
void setLado2(double lado2) { this->lado2 = lado2; }
double getLado1() const { return lado1; }
double getLado2() const { return lado2; }
~Rectangulo(){};
};
int main() {
Rectangulo rect(5.0, 3.0);
cout<<"lados: "<<rect.getLado1()<<", "<<rect.getLado2()<<endl;
rect.setLado1(10.234);
rect.setLado2(23);
cout<<"lados: "<<rect.getLado1()<<", "<<rect.getLado2()<<endl;
return 0;
}
Ejemplo3
Se denomina sobrecarga de métodos cuando se definen dos o más métodos con el
mismo nombre, pero diferente número o tipo de parámetros.
Crea una clase Sumador con un método sumar(double a, double b) que devuelva la suma
de a y b; luego el método sumar(double a, double b, double c) que devuelva la suma de
a, b y c; y por último el método sumar(float a, float b) que también devuelva la suma de a
y b.
#include <iostream>
using namespace std;
class Sumador {
public:
double suma(double a, double b) {
return a+b;
}
double suma(double a, double b, double c) {
return a+b+c;
}
double suma(float a, float b) {
return a+b;
}
};
int main() {
Sumador sumas;
9
UNIVERSIDAD AUTONOMA “JUAN MISAEL SARACHO”
FACULTAD DE CIENCIAS Y TECNOLOGIA
CARRERA DE INGENIERIA INFORMÁTICA
º
cout<<[Link](2.3, 5.23)<<endl;
cout<<[Link](2.3, 5.23, -10.2)<<endl;
cout<<[Link](3.2F, 8.23F)<<endl;
return 0;
}
Ejemplo4
Define la clase CuentaBancaria con atributos privados: saldo y titular, protegido:
tipoCuenta y los métodos públicos: constructor con argumentos, depositar(cantidad),
retirar(cantidad), getSaldo(), setSaldo(nuevoSaldo), gettitular() y getTipoCuenta(); luego
escribir el método principal que un objeto de la clase CuentaBancaria en el heap y use
sus métodos.
#include <iostream>
#include <string>
using namespace std;
class CuentaBancaria {
private:
string titular;
double saldo;
protected:
string tipoCuenta; // Atributo protegido: puede ser accedido
por clases derivadas
public:
CuentaBancaria(string t, double s, string tipo):titular(t),
saldo(s), tipoCuenta(tipo){}
void imprimir() const {
cout << "Titular: " << titular << endl;
cout << "Saldo: " << saldo << endl;
cout << "Tipo de cuenta: " << tipoCuenta << endl;
}
void depositar(double cantidad) {
if (cantidad > 0) {
saldo += cantidad;
cout << "Depósito exitoso. Nuevo saldo: " << saldo
<<endl;
} else {
cout << "Cantidad inválida para depósito." << endl;
}
}
void retirar(double cantidad) {
if (cantidad > 0 && cantidad <= saldo) {
saldo -= cantidad;
cout << "Retiro exitoso. Nuevo saldo: " << saldo <<
endl;
10
UNIVERSIDAD AUTONOMA “JUAN MISAEL SARACHO”
FACULTAD DE CIENCIAS Y TECNOLOGIA
CARRERA DE INGENIERIA INFORMÁTICA
º
} else {
cout << "Saldo insuficiente o cantidad inválida." <<
endl;
}
}
double getSaldo() const {
return saldo;
}
void setSaldo(double nuevoSaldo) {
if (nuevoSaldo >= 0) {
saldo = nuevoSaldo;
} else {
cout << "El saldo no puede ser negativo." << endl;
}
}
string getTitular() const {
return titular;
}
string getTipoCuenta() const {
return tipoCuenta;
}
};
int main() {
CuentaBancaria* cuenta = new CuentaBancaria("Juan Pérez",
5000.0, "Cuenta de Ahorros");
cuenta->imprimir();
cuenta->depositar(1500.0);
cuenta->retirar(1000.0);
cuenta->retirar(10000.0);
return 0;
}
6.- Modificar el anterior ejercicio y permitir que se ingresen todos los datos desde teclado
11
UNIVERSIDAD AUTONOMA “JUAN MISAEL SARACHO”
FACULTAD DE CIENCIAS Y TECNOLOGIA
CARRERA DE INGENIERIA INFORMÁTICA
º
#include <iostream>
#include <string>
using namespace std;
class CuentaBancariaf {
private:
string titular;
double saldo;
protected:
string tipoCuenta; // Atributo protegido: puede ser accedido por clases
derivadas
public:
//usamos los parámetros del método de constructor como una lista de
inicialización
//CuentaBancariaf(string t, double s, string tipo):titular(t), saldo(s),
tipoCuenta(tipo){}
CuentaBancariaf(){};
void inicializaconst(string t, double s, string tipo)
{
titular=t;
saldo=s;
tipoCuenta=tipo;
}
void imprimir() const {
cout << "Titular: " << titular << endl;
cout << "Saldo: " << saldo << endl;
cout << "Tipo de cuenta: " << tipoCuenta << endl;
}
void depositar(double cantidad) {
if (cantidad > 0) {
saldo += cantidad;
cout << "Depósito exitoso, Nuevo saldo: " << saldo << endl;
} else {
cout << "Cantidad inválida para depósito." << endl;
}
}
void retirar(double cantidad) {
if (cantidad > 0 && cantidad <= saldo) {
saldo -= cantidad;
cout << "Retiro exitoso. Nuevo saldo: " << saldo << endl;
} else {
cout << "Saldo insuficiente o cantidad inválida." << endl;
}
}
double getSaldo() const {
return saldo;
12
UNIVERSIDAD AUTONOMA “JUAN MISAEL SARACHO”
FACULTAD DE CIENCIAS Y TECNOLOGIA
CARRERA DE INGENIERIA INFORMÁTICA
º
}
void setSaldo(double nuevoSaldo) {
if (nuevoSaldo >= 0) {
saldo = nuevoSaldo;
} else {
cout << "El saldo no puede ser negativo." << endl;
}
}
void setTitular(string nuevotitular) {
titular=nuevotitular;
}
void setTipoCuenta(string nuevotipocuenta) {
tipoCuenta=nuevotipocuenta;
}
string getTitular() const {
return titular;
}
string getTipoCuenta() const {
return tipoCuenta;
}
};
int main() {
//CuentaBancariaf* cuenta = new CuentaBancariaf("Juan Pérez", 5000.0, "Cuenta
de Ahorros");
CuentaBancariaf cuenta1;
string tit;
double sal;
string tipo;
double nuevodeposito,montoretiro;
cout<<"saldo: ";
cin>>sal;
cout<<"titular";
cin>>tit;
cout<<"Tipo cuenta";
cin>>tipo;
[Link](sal);
[Link](tit);
[Link](tipo);
[Link](tit,sal,tipo);
cout<<"Ingrese el monto a depositar: ";
cin>>nuevodeposito;
13
UNIVERSIDAD AUTONOMA “JUAN MISAEL SARACHO”
FACULTAD DE CIENCIAS Y TECNOLOGIA
CARRERA DE INGENIERIA INFORMÁTICA
º
[Link](nuevodeposito);
cout<<"Ingrese el monto a retirar: ";
cin>>montoretiro;
[Link](montoretiro);
[Link]();
cout<<"Saldo actual es igual a: "<<[Link]()<<endl;
return 0;
}
14
