Blogia

sounix

5.3.2 CONCEPTO DE PARAMETRO

LOS PARAMETROS

Un parámetro es un método para pasar información (valores a variables) del programa principal a un módulo o viceversa.

Un parámetro es prácticamente, una variable cuyo valor debe ser o bien proporcionado por el programa principal al módulo o ser devuelto desde el módulo hasta el programa principal. Por consiguiente hay dos tipos de parámetros: entrada y salida.

Los parámetros de entrada son aquellos cuyos valores deben ser proporcionados por el programa principal, y los de salida son aquellos cuyos valores se calcularán en el subprograma o módulo y se deben devolver al programa principal para su proceso posterior.

Los módulos o subprogramas sirven para ejecutar tareas concretas, pero no utilizan ningún tipo de dato del resto del programa. Sin embargo, una de las características importantes y diferenciadora de los subprogramas es la posibilidad de comunicación entre el programa principal y los subprogramas (o entre los subprogramas). Esta comunicación se realiza a través de una lista de parámetros

Módulos con parámetros (existe comunicación entre el programa principal y los módulos, y entre ellos).

Las sentencias llamadas a subprogramas constan de dos partes: un nombre de subprograma y una lista de parámetros llamados actuales.

En la declaración de un subprograma, cuando se incluyen parámetros, estos se denominan parámetros formales o ficticios.

5.3.3 PARAMETROS DE ENTRADA Y SALIDA

Tipos de Parametros

* Parámetros de entrada/salida: estos parámetros son usados inicialmente para introducir los datos a la subrutina y después guardar los resultados obtenidos.

* Parámetros de entrada: estos parámetros son usados solo para introducir datos en la subrutina. Su valor no cambia a la salida.

* Parámetros de salida: Devuelven los resultados obtenidos. Uno de estos parámetros (ICON) nos indicará la situación después de la ejecución.

Normalmente, los parámetros son ordenados siguiendo el siguiente esquema:
(parámetros de entrada/salida, parámetros de entrada, parámetros de salida)
Parámetros de salida

Un parámetro de salida se diferencia de uno de entrada en que todo cambio que se le realice en el código del método al que pertenece afectará al objeto que se le pase al llamar dicho método tanto si éste es de un tipo por como si es de un tipo referencia. Esto se debe a que lo que a estos parámetros se les pasa es siempre una referencia al valor que almacenaría una variable del tipo del objeto que se les pase.

Cualquier parámetro de salida de un método siempre ha de modificarse dentro del cuerpo del método y además dicha modificación ha de hacerse antes que cualquier lectura de su valor. Si esto no se hiciese así el compilador lo detectaría e informaría de ello con un error. Por esta razón es posible pasar parámetros de salida que sean variables no inicializadas, pues se garantiza que en el método se inicializarán antes de leerlas. Además, tras la llamada a un método se considera que las variables que se le pasaron como parámetros de salida ya estarán inicializadas, pues dentro del método seguro que se las inicializació.

Nótese que este tipo de parámetros permiten diseñar métodos que devuelvan múltiples objetos: un objeto se devolvería como valor de retorno y los demás se devolverían escribiendos en los parámetros de salida.

Los parámetros de salida se definen de forma parecida a los parámetros de entrada pero se les ha de añadir la palabra reservada out. O sea, se definen así:

out

Al llamar a un método que tome parámetros de este tipo también se ha preceder el valor especificado para estos parámetros del modificador out. Una utilidad de esto es facilitar la legibilidad de las llamadas a métodos. Por ejemplo, dada una llamada de la forma:
a.f(x, out z)

Es fácil determinar que lo que se hace es llamar al método f() del objeto a pasándole x como parámetro de entrada y z como parámetro de salida. Además, también se puede deducir que el valor de z cambiará tras la llamada.

Sin embargo, la verdadera utilidad de forzar a explicitar en las llamadas el tipo de paso de cada parámetro es que permite evitar errores derivados de que un programador pase una variable a un método y no sepa que el método la puede modificar. Teniéndola que explicitar se asegura que el programador sea consciente de lo que hace.
Parámetros de Entrada

Un parámetro de entrada recibe una copia del valor que almacenaría una variable del tipo del objeto que se le pase. Por tanto, si el objeto es de un tipo valor se le pasará una copia del objeto y cualquier modificación que se haga al parámetro dentro del cuerpo del método no afectará al objeto original sino a su copia; mientras que si el objeto es de un tipo referencia entonces se le pasará una copia de la referencia al mismo y cualquier modificación que se haga al parámetro dentro del método también afectará al objeto original ya que en realidad el parámetro referencia a ese mismo objeto original.

Para definir un parámetro de entrada basta indicar cuál el nombre que se le desea dar y el cuál es tipo de dato que podrá almacenar. Para ello se sigue la siguiente sintaxis:

5.3.4 EL CONSTRUCTOR

Los constructores son funciones miembro especiales que sirven para inicializar un objeto de una determinada clase al mismo tiempo que se declara.

Los constructores tienen el mismo nombre que la clase, no retornan ningún valor y no pueden ser heredados. Además deben ser públicos, no tendría ningún sentido declarar un constructor como privado, ya que siempre se usan desde el exterior de la clase, ni tampoco como protegido, ya que no puede ser heredado.

Añadamos un constructor a nuestra clase pareja:

#include
using namespace std;

class pareja {
public:
// Constructor
pareja(int a2, int b2);
// Funciones miembro de la clase "pareja"
void Lee(int &a2, int &b2);
void Guarda(int a2, int b2);
private:
// Datos miembro de la clase "pareja"
int a, b;
public:
};

pareja::pareja(int a2, int b2) {
a = a2;
b = b2;
}

void pareja::Lee(int &a2, int &b2) {
a2 = a;
b2 = b;
}

void pareja::Guarda(int a2, int b2) {
a = a2;
b = b2;
}

int main() {
pareja par1(12, 32);
int x, y;

par1.Lee(x, y);
cout

5.3.5 EL DESTRUCTOR

Los destructores son funciones miembro especiales que sirven para eliminar un objeto de una determinada clase, liberando la memoria utilizada por dicho objeto.

Los destructores tienen el mismo nombre que la clase, pero con el símbolo ~ delante, no retornan ningún valor y no pueden ser heredados.

Cuando se define un destructor para una clase, éste es llamado automáticamente cuando se abandona el ámbito en el que fue definido. Esto es así salvo cuando el objeto fue creado dinámicamente con el operador new, ya que en ese caso, si es necesario eliminarlo, hay que usar el operador delete.

En general, será necesario definir un destructor cuando nuestra clase tenga datos miembro de tipo puntero, aunque esto no es una regla estricta. El destructor no puede sobrecargarse, por la sencilla razón de que no admite argumentos.

Ejemplo:

#include
#include
using namespace std;

class cadena {
public:
cadena(); // Constructor por defecto
cadena(char *c); // Constructor desde cadena c
cadena(int n); // Constructor de cadena de n caracteres
cadena(const cadena &); // Constructor copia
~cadena(); // Destructor

void Asignar(char *dest);
char *Leer(char *c);
private:
char *cad; // Puntero a char: cadena de caracteres
};

cadena::cadena() : cad(NULL) {}

cadena::cadena(char *c) {
cad = new char[strlen(c)+1];// Reserva memoria para cadena
strcpy(cad, c); // Almacena la cadena
}

cadena::cadena(int n) {
cad = new char[n+1]; // Reserva memoria para n caracteres
cad[0] = 0; // Cadena vacía
}

cadena::cadena(const cadena &Cad) {
// Reservamos memoria para la nueva y la almacenamos
cad = new char[strlen(Cad.cad)+1];
// Reserva memoria para cadena
strcpy(cad, Cad.cad); // Almacena la cadena
}

cadena::~cadena() {
delete[] cad; // Libera la memoria reservada a cad
}

void cadena::Asignar(char *dest) {
// Eliminamos la cadena actual:
delete[] cad;
// Reservamos memoria para la nueva y la almacenamos
cad = new char[strlen(dest)+1];
// Reserva memoria para la cadena
strcpy(cad, dest); // Almacena la cadena
}

char *cadena::Leer(char *c) {
strcpy(c, cad);
return c;
}

int main() {
cadena Cadena1("Cadena de prueba");
cadena Cadena2(Cadena1); // Cadena2 es copia de Cadena1
cadena *Cadena3; // Cadena3 es un puntero
char c[256];

// Modificamos Cadena1:
Cadena1.Asignar("Otra cadena diferente");
// Creamos Cadena3:
Cadena3 = new cadena("Cadena de prueba nº 3");

// Ver resultados
cout

Descubrimiento del dia :D

Hoy me acabo de acordar que tenia este blog :D se que parece estupido peor no recordaba que me habia registrado hace un buen.

Bienvenido al weblog sounix

Gracias por visitarme ;-)