Cuando uno plantea una clase en lugar de especificar todo el algoritmo en la main (lo que hicimos en los primeros pasos de este tutorial) es dividir todas las responsabilidades de la clase en un conjunto de métodos.
Un método hemos visto que tiene la siguiente sintaxis:
void [nombre de la clase]::[nombre del método]()
{
[algoritmo]
}
Veremos que hay varios tipos de métodos:
Un método puede tener parámetros:
void [nombre de la clase]::[nombre del método]([parámetros])
{
[algoritmo]
}
Los parámetros los podemos imaginar como variables locales al método, pero su valor se inicializa con datos que llegan cuando lo llamamos.
Confeccionar una clase que permita ingresar valores enteros por teclado y nos muestre la tabla de multiplicar de dicho valor. Finalizar el programa al ingresar el -1.
#include<iostream>
using namespace std;
class TablaMultiplicar {
private:
void calcular(int v);
public:
void cargarValor();
};
void TablaMultiplicar::calcular(int v)
{
for(int f=v;f<=v*10;f=f+v)
{
cout <<f;
cout <<"-";
}
cout <<"\n";
}
void TablaMultiplicar::cargarValor()
{
int valor;
do
{
cout <<"Ingrese un valor (-1 para finalizar):";
cin >>valor;
if (valor != -1)
{
calcular(valor);
}
} while (valor != -1);
}
int main()
{
TablaMultiplicar tabla1;
tabla1.cargarValor();
return 0;
}
Este proyecto lo puede descargar en un zip desde este enlace : MetodosConParametros
En esta clase no hemos definido ningún atributo. Hemos declarado el método calcular en la zona private (ya que no lo llamaremos desde la main) Luego iremos viendo cuando conviene definir métodos públicos y privados (los métodos públicos son aquellos que podemos llamar desde fuera de la clase, por ahora desde la main pero luego veremos que un problema puede tener más de una clase)
El método calcular recibe un parámetro de tipo entero, luego lo utilizamos dentro del método para mostrar la tabla de multiplicar de dicho valor, para esto inicializamos la variable f con el valor que llega en el parámetro. Luego de cada ejecución del for incrementamos el contador f con el valor del parámetro v.
void TablaMultiplicar::calcular(int v)
{
for(int f=v;f<=v*10;f=f+v)
{
cout <<f;
cout <<"-";
}
cout <<"\n";
}
Un método puede no tener parámetros como hemos visto en problemas anteriores o puede tener uno o más parámetros (en caso de tener más de un parámetro los mismos se separan por coma)
El método cargarValores no tiene parámetros y tiene por objetivo cargar un valor entero por teclado y llamar al método calcular para que muestre la tabla de multiplicar del valor que le pasamos por teclado:
void TablaMultiplicar::cargarValor()
{
int valor;
do
{
cout <<"Ingrese un valor (-1 para finalizar):";
cin >>valor;
if (valor != -1)
{
calcular(valor);
}
} while (valor != -1);
}
Como vemos al método calcular lo llamamos por su nombre y entre paréntesis le pasamos el dato a enviar (debe ser un valor o variable entera)
En este problema en la main solo llamamos al método cargarValor, ya que el método calcular luego es llamado por el método cargarValor (tampoco podríamos llamar al método calcular desde la main esto debido a que está definido en la parte private de la clase):
int main()
{
TablaMultiplicar tabla1;
tabla1.cargarValor();
return 0;
}
Un método puede retornar un dato:
[tipo de dato] [nombre de la clase]::[nombre del método]([parámetros])
{
[algoritmo]
return [tipo de dato]
}
Cuando un método retorna un dato en vez de indicar la palabra clave void (que significa vacío) previo al nombre del método indicamos el tipo de dato que retorna. Luego dentro del algoritmo en el momento que queremos que finalice el mismo y retorne el dato empleamos la palabra clave return con el valor respectivo.
Confeccionar una clase que permita ingresar tres valores por teclado. Luego mostrar el mayor y el menor. Retornar dichos valores mediante el return.
#include<iostream>
using namespace std;
class MayorMenor {
private:
int calcularMayor(int v1,int v2,int v3);
int calcularMenor(int v1,int v2,int v3);
public:
void cargarValores();
};
int MayorMenor::calcularMayor(int v1,int v2,int v3)
{
int m;
if (v1 > v2 && v1 > v3)
{
m = v1;
}
else
{
if (v2 > v3)
{
m = v2;
}
else
{
m = v3;
}
}
return m;
}
int MayorMenor::calcularMenor(int v1,int v2,int v3)
{
int m;
if (v1 < v2 && v1 < v3)
{
m = v1;
}
else
{
if (v2 < v3)
{
m = v2;
}
else
{
m = v3;
}
}
return m;
}
void MayorMenor::cargarValores()
{
int valor1,valor2,valor3;
cout <<"Ingrese primer valor:";
cin >>valor1;
cout <<"Ingrese segundo valor:";
cin >>valor2;
cout <<"Ingrese tercer valor:";
cin >>valor3;
int mayor, menor;
mayor = calcularMayor(valor1, valor2, valor3);
menor = calcularMenor(valor1, valor2, valor3);
cout <<"El valor mayor de los tres es:";
cout <<mayor;
cout <<"\n";
cout <<"El valor menor de los tres es:";
cout <<menor;
cin.get();
cin.get();
}
int main()
{
MayorMenor mayormenor1;
mayormenor1.cargarValores();
return 0;
}
Este proyecto lo puede descargar en un zip desde este enlace : MetodosRetornanDato
Si vemos la sintaxis que calcula el mayor de tres valores enteros es similar al algoritmo visto en conceptos anteriores:
Lo primero que podemos observar que el método retorna un entero y recibe tres parámetros:
int MayorMenor::calcularMayor(int v1,int v2,int v3)
Dentro del método verificamos cual de los tres parámetros almacena un valor mayor, a este valor lo almacenamos en una variable local llamada "m", al valor almacenado en esta variable lo retornamos al final con un return.
La llamada al método calcularMayor lo hacemos desde dentro del método cargarCalores:
mayor = calcularMayor(valor1, valor2, valor3);
Debemos asignar a una variable el valor devuelto por el método calcularMayor. Luego el contenido de la variable mayor lo mostramos:
cout <<"El valor mayor de los tres es:";
cout <<mayor;
La lógica es similar para el cálculo del menor.
Es importante notar que definimos los dos métodos calcularMayor y calcularMenor en la zona private (esto hace que no podamos llamarlos desde la main (significa que estos dos métodos solo pueden ser llamados desde otros métodos de la misma clase)
class MayorMenor {
private:
int calcularMayor(int v1,int v2,int v3);
int calcularMenor(int v1,int v2,int v3);
public:
void cargarValores();
};
Si los definimos en la zona public el programa sigue funcionando pero si queremos que no puedan ser llamados desde la main y queden encapsulados en la clase debemos definirlos en la zona private.
#include<iostream>
using namespace std;
class MostrarHasta {
private:
void mostrarEnteros(int valor);
public:
void cargar();
};
void MostrarHasta::mostrarEnteros(int valor)
{
for (int f = 1; f <= valor; f++)
{
cout << f;
cout << "-";
}
}
void MostrarHasta::cargar()
{
int val;
cout << "Ingresar un valor entero:";
cin >> val;
mostrarEnteros(val);
}
int main()
{
MostrarHasta mostrarHasta1;
mostrarHasta1.cargar();
return 0;
}
Este proyecto lo puede descargar en un zip desde este enlace :MetodosMostrarEnteros
#include<iostream>
using namespace std;
class MayorDos {
private:
int mayor(int v1, int v2);
public:
void cargar();
};
int MayorDos::mayor(int v1, int v2)
{
if (v1 > v2)
{
return v1;
}
else
{
return v2;
}
}
void MayorDos::cargar()
{
int valor1, valor2;
cout <<"Ingrese primer valor:";
cin >> valor1;
cout << "Ingrese segundo valor:";
cin >> valor2;
int resu = mayor(valor1, valor2);
cout << "El valor mayor de los numeros ingresados es:";
cout << resu;
cin.get();
cin.get();
}
int main()
{
MayorDos mayordos1;
mayordos1.cargar();
return 0;
}
Este proyecto lo puede descargar en un zip desde este enlace :MetodosRetornarMayor