Normalmente un problema resuelto con la metodología de programación orientada a objetos no interviene una sola clase, sino que hay muchas clases que interactúan y se comunican.
Plantearemos un problema separando las actividades en dos clases.
Un banco tiene 3 clientes que pueden hacer depósitos y extracciones. También el banco requiere que al final del día calcule la cantidad de dinero que hay depositada.
Lo primero que hacemos es identificar las clases:
Podemos identificar la clase Cliente y la clase Banco.
Luego debemos definir los atributos y los métodos de cada clase:
Cliente
atributos
nombre
monto
métodos
constructor
depositar
extraer
retornarMonto
Banco
atributos
3 Cliente (3 objetos de la clase Cliente)
métodos
constructor
operar
depositosTotales
Creamos un proyecto en el Visual Studio y en un archivo llamado "archivo1.cpp" codificamos lo siguiente:
#include<iostream>
using namespace std;
class Cliente {
char nombre[40];
float monto;
public:
Cliente(const char nom[40]);
void depositar(int m);
void extraer(int m);
float retornarMonto();
void imprimir();
};
class Banco {
Cliente cliente1, cliente2, cliente3;
public:
Banco();
void operar();
void depositiosTotales();
};
Cliente::Cliente(const char nom[40])
{
strcpy_s(nombre, nom);
monto = 0;
}
void Cliente::depositar(int m)
{
monto = monto + m;
}
void Cliente::extraer(int m)
{
monto = monto - m;
}
float Cliente::retornarMonto()
{
return monto;
}
void Cliente::imprimir()
{
cout << "Nombre:" << nombre << " Monto:" << monto << "\n\n";
}
Banco::Banco() :cliente1("juan"), cliente2("pedro"), cliente3("luis")
{
}
void Banco::operar()
{
cliente1.depositar(100);
cliente2.depositar(150);
cliente3.depositar(200);
cliente3.extraer(150);
}
void Banco::depositiosTotales()
{
float t = cliente1.retornarMonto() + cliente2.retornarMonto() + cliente3.retornarMonto();
cout << "El total de dinero en el banco es:" << t << "\n\n";
cliente1.imprimir();
cliente2.imprimir();
cliente3.imprimir();
}
int main()
{
Banco banco1;
banco1.operar();
banco1.depositiosTotales();
return 0;
}
Este proyecto lo puede descargar en un zip desde este enlace : Colaboracion1.zip
Analicemos la implementación del problema.
Los atributos de una clase normalmente son privados para que no se tenga acceso directamente desde otra clase, los atributos son modificados por los métodos de la misma clase:
class Cliente {
char nombre[40];
float monto;
public:
Cliente(const char nom[40]);
void depositar(int m);
void extraer(int m);
float retornarMonto();
void imprimir();
};
El constructor recibe como parámetro el nombre del cliente (debemos agregar el modificador const ya que le pasaremos una cadena fija) y lo almacena en el atributo respectivo e inicializa el atributo monto en cero:
Cliente::Cliente(const char nom[40])
{
strcpy_s(nombre, nom);
monto = 0;
}
Los métodos depositar y extraer actualizan el atributo monto con el dinero que llega como parámetro (para simplificar el problema no hemos validado que cuando se extrae dinero el atributo monto quede con un valor negativo):
void Cliente::depositar(int m)
{
monto = monto + m;
}
void Cliente::extraer(int m)
{
monto = monto - m;
}
El método retornarMonto tiene por objetivo comunicar al Banco la cantidad de dinero que tiene el cliente (tengamos en cuenta que como el atributo monto es privado de la clase, debemos tener un método que lo retorne):
float Cliente::retornarMonto()
{
return monto;
}
Por último el método imprimir muestra nombre y el monto de dinero del cliente:
void Cliente::imprimir()
{
cout << "Nombre:" << nombre << " Monto:" << monto<<"\n\n";
}
Como podemos observar en la main no definimos objetos de la clase Cliente. ¿Entonces donde definimos objetos de la clase Cliente?
La respuesta a esta pregunta es que en la clase Banco definimos tres objetos de la clase Cliente.
Veamos ahora la clase Banco que requiere la colaboración de la clase Cliente.
Primero definimos tres atributos de tipo Cliente:
class Banco {
Cliente cliente1, cliente2, cliente3;
public:
Banco();
void operar();
void depositiosTotales();
};
Para poder inicializar los tres objetos de la clase Cliente en la clase Banco lo debemos hacer en el constructor::
Banco::Banco() :cliente1("juan") , cliente2("pedro") , cliente3("luis")
{
}
Podemos observar que realmente el código del constructor de la clase Banco está vacío pero en la parte de la declaración de la cabecera del método disponemos dos puntos y seguidamente llamamos al constructor de cada uno de los objetos de la clase Cliente pasando el nombre del cliente respectivo (sin no hacemos esto nos genera un error sintáctico ya que el constructor de la clase Cliente tiene como parámetro una cadena de caracteres)
El método operar del banco (llamamos a los métodos depositar y extraer de los clientes):
void Banco::depositiosTotales()
{
float t = cliente1.retornarMonto() + cliente2.retornarMonto() + cliente3.retornarMonto();
cout <<"El total de dinero en el banco es:"<<t<<"\n\n";
cliente1.imprimir();
cliente2.imprimir();
cliente3.imprimir();
}
El método depositosTotales obtiene el monto depositado de cada uno de los tres clientes, procede a mostrarlos y llama al método imprimir de cada cliente para poder mostrar el nombre y depósito:
void Banco::depositiosTotales()
{
float t = cliente1.retornarMonto() + cliente2.retornarMonto() + cliente3.retornarMonto();
cout <<"El total de dinero en el banco es:"<<t<<"\n\n";
cliente1.imprimir();
cliente2.imprimir();
cliente3.imprimir();
}
Por último en la main definimos un objeto de la clase Banco (la clase Banco es la clase principal en nuestro problema):
int main()
{
Banco banco1;
banco1.operar();
banco1.depositiosTotales();
return 0;
}
Plantear un programa que permita jugar a los dados. Las reglas de juego son: se tiran tres dados si los tres salen con el mismo valor mostrar un mensaje que "gano", sino "perdió".
Lo primero que hacemos es identificar las clases:
Podemos identificar la clase Dado y la clase JuegoDeDados.
Luego los atributos y los métodos de cada clase:
Dado
atributos
valor
métodos
tirar
imprimir
retornarValor
JuegoDeDados
atributos
3 Dado (3 objetos de la clase Dado)
métodos
jugar
Creamos un proyecto en el VisualStudio e implementamos el siguiente código.
#include<iostream>
#include<cstdlib>
#include<ctime>
using namespace std;
class Dado {
int valor;
public:
void tirar();
void imprimir();
int retornarValor();
};
class JuegoDeDados {
Dado dado1, dado2, dado3;
public:
void jugar();
};
void Dado::tirar()
{
valor = rand() % 6 + 1;
}
void Dado::imprimir()
{
cout << "Valor del Dado:" << valor << "\n";
}
int Dado::retornarValor()
{
return valor;
}
void JuegoDeDados::jugar()
{
dado1.tirar();
dado1.imprimir();
dado2.tirar();
dado2.imprimir();
dado3.tirar();
dado3.imprimir();
if (dado1.retornarValor() == dado2.retornarValor() &&
dado1.retornarValor() == dado3.retornarValor())
{
cout<<"Gano";
}
else
{
cout<<"Perdio";
}
}
int main()
{
srand(time(NULL));
JuegoDeDados juego1;
juego1.jugar();
return 0;
}
Este proyecto lo puede descargar en un zip desde este enlace : Colaboracion2.zip
La clase Dado define el atributo "valor" donde almacenamos un valor aleatorio que representa el número que sale al tirarlo.
class Dado {
int valor;
public:
void tirar();
void imprimir();
int retornarValor();
};
El método tirar almacena el valor aleatorio:
void Dado::tirar()
{
valor = rand() % 6 + 1;
}
El método imprimir de la clase Dado muestra por pantalla el valor del dado:
void Dado::imprimir()
{
cout << "Valor del Dado:" << valor << "\n";
}
Por último el método que retorna el valor del dado (se utiliza en la otra clase para ver si los tres dados generaron el mismo valor):
int Dado::retornarValor()
{
return valor;
}
La clase JuegoDeDatos define tres atributos de la clase Dado (con esto decimos que la clase Dado colabora con la clase JuegoDeDados):
class JuegoDeDados {
Dado dado1, dado2, dado3;
public:
void jugar();
};
No hace falta definir constructor en la clase JuegoDeDados ya que no tenemos que inicializar los tres objetos de la clase Dado debido a que no tienen constructor la clase Dado.
En el método jugar llamamos al método tirar de cada dado, pedimos que se imprima el valor generado y finalmente procedemos a verificar si se ganó o no:
void JuegoDeDados::jugar()
{
dado1.tirar();
dado1.imprimir();
dado2.tirar();
dado2.imprimir();
dado3.tirar();
dado3.imprimir();
if (dado1.retornarValor() == dado2.retornarValor() &&
dado1.retornarValor() == dado3.retornarValor())
{
cout<<"Gano";
}
else
{
cout<<"Perdio";
}
}
En la main creamos solo un objeto de la clase principal (en este caso la clase principal es el JuegoDeDados) y también iniciamos la semilla de valores aleatorios llamando a la función srand:
int main()
{
srand(time(NULL));
JuegoDeDados juego1;
juego1.jugar();
return 0;
}
#include<iostream>
using namespace std;
class Socio {
char nombre[40];
int antiguedad;
public:
Socio();
void imprimir();
int retornarAntiguedad();
};
class Club {
Socio socio1, socio2, socio3;
public:
void mayorAntiguedad();
};
Socio::Socio()
{
cout << "Ingrese nombre:";
cin.getline(nombre, 40);
cout << "Ingrese antiguedad:";
cin >> antiguedad;
cin.get();
}
void Socio::imprimir()
{
cout << "Nombre:" << nombre << " Antiguedad:" << antiguedad << "\n\n";
}
int Socio::retornarAntiguedad()
{
return antiguedad;
}
void Club::mayorAntiguedad()
{
cout << "Socio con mayor antiguedad\n";
if (socio1.retornarAntiguedad() > socio2.retornarAntiguedad() &&
socio1.retornarAntiguedad() > socio3.retornarAntiguedad())
{
socio1.imprimir();
}
else
{
if (socio2.retornarAntiguedad() > socio3.retornarAntiguedad())
{
socio2.imprimir();
}
else
{
socio3.imprimir();
}
}
}
int main()
{
Club club1;
club1.mayorAntiguedad();
return 0;
}
Este proyecto lo puede descargar en un zip desde este enlace :Colaboracion3.zip