tutorialesya.com.

ar

http://www.tutorialesya.com.ar/cmasmasya/detalleconcepto.php?punto=14&codigo=141&inicio=0

14 - Sintaxis de un mtodo
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 las clase en un conjunto de mtodos.
Un mtodo hemos visto que tiene la siguiente sintaxis:
void [nombre de la clase]::[nombre del mtodo]()
{
[algoritmo]
}
Veremos que hay varios tipos de mtodos:

Mtodos con parmetros.

Un mtodo puede tener parmetros:
void [nombre de la clase]::[nombre del mtodo]([parmetros])
{
[algoritmo]
}
Los parmetros los podemos imaginar como variables locales al mtodo, pero su valor se inicializa con datos que
llegan cuando lo llamamos.

Problema 1:
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.

Programa:
#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);
}
void main()
{
TablaMultiplicar tabla1;
tabla1.cargarValor();
}

Este proyecto lo puede descargar en un zip desde este enlace : MetodosConParametros

En esta clase no hemos definido ningn atributo. Hemos declarado el mtodo calcular en la zona private (ya que
no lo llamaremos desde la main) Luego iremos viendo cuando conviene definir mtodos pblicos y privados (los
mtodos pblicos son aquellos que podemos llamar desde fuera de la clase, por ahora desde la main pero luego
veremos que un problema puede tener ms de una clase)
El mtodo calcular recibe un parmetro de tipo entero, luego lo utilizamos dentro del mtodo para mostrar la tabla
de multiplicar de dicho valor, para esto inicializamos la variable f con el valor que llega en el parmetro. Luego de
cada ejecucin del for incrementamos el contador f con el valor del parmetro v.
void TablaMultiplicar::calcular(int v)
{
for(int f=v;f<=v*10;f=f+v)
{
cout <<f;
cout <<"-";
}
cout <<"\n";
}
Un mtodo puede no tener parmetros como hemos visto en problemas anteriores o puede tener uno o ms
parmetros (en caso de tener ms de un parmetro los mismos se separan por coma)
El mtodo cargarValores no tiene parmetros y tiene por objetivo cargar un valor entero por teclado y llamar al
mtodo 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 mtodo calcular lo llamamos por su nombre y entre parntesis le pasamos el dato a enviar (debe
ser un valor o variable entera)
En este problema en la main solo llamamos al mtodo cargarValor, ya que el mtodo calcular luego es llamado
por el mtodo cargarValor (tampoco podramos llamar al mtodo calcular desde la main esto debido a que est
definido en la parte private de la clase):
void main()
{
TablaMultiplicar tabla1;
tabla1.cargarValor();
}

Mtodos que retornan un dato.

Un mtodo puede retornar un dato:
[tipo de dato] [nombre de la clase]::[nombre del mtodo]([parmetros])
{
[algoritmo]
return [tipo de dato]
}
Cuando un mtodo retorna un dato en vez de indicar la palabra clave void (que significa vaco) previo al nombre
del mtodo 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.

Problema 2:
Confeccionar una clase que permita ingresar tres valores por teclado. Luego mostrar el mayor y el menor.
Retornar dichos valores mediante el return.

Programa:
#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();
}
void main()
{
MayorMenor mayormenor1;
mayormenor1.cargarValores();
}
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 mtodo retorna un entero y recibe tres parmetros:
int MayorMenor::calcularMayor(int v1,int v2,int v3)
Dentro del mtodo verificamos cual de los tres parmetros 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 mtodo calcularMayor lo hacemos desde dentro del mtodo cargarCalores:
mayor = calcularMayor(valor1, valor2, valor3);
Debemos asignar a una variable el valor devuelto por el mtodo calcularMayor. Luego el contenido de la variable
mayor lo mostramos:
cout <<"El valor mayor de los tres es:";
cout <<mayor;
La lgica es similar para el clculo del menor.
Es importante notar que definimos los dos mtodos calcularMayor y calcularMenor en la zona private (esto hace
que no podamos llamarlos desde la main (significa que estos dos mtodos solo pueden ser llamados desde otros
mtodos 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.

Problemas propuestos

1. Plantear una clase que permita cargar un valor entero por teclado. Definir un mtodo que solicite la carga
del entero y llame a otro mtodo al que le pasamos el valor ingresado y proceda a mostrar los valores
enteros desde el 1 hasta el valor que llega como parmetro (es decir el ingresado por teclado)
2. Desarrollar una clase con dos mtodos, uno para la carga de dos enteros. Definir un mtodo privado que le
enviemos los valores ingresados por teclado y nos retorne el mayor de ellos.
Solucin

Retornar