PARADIGMAS

SOBRECARGA PARADIGMA
Hay que tener cuidado al elegir a los enemigos
porque uno termina pareciéndose a ellos..!!
Jorge Luis Borges
Qué es SOBRECARGA..??
Declaraciones
Métodos
| Volver | | Arbol | | Archivo | | Base de dato | Basico | | Cola y Pila |
| Editor | | Editor2 | | Fibonacci | | Hanoi | | Listas | | Matriz |
| Modelo 1 | | Modelo | | Polimorfismo | Punteros | | Agenda | | Vectores |
PARADIGMA
No hay malas yerbas u hombres malos..
solo hay malos cultivadores..!!
Voltaire
//////////////////////////////////////////////////////////////////
// C++ Builder Wilo Carpio
// SobreCarga.cpp MatrizSobrecarga.h MatrizSobrecarga.cpp
/////////////////////////////////////////////////////////////////
// SOBRECARGA:
// Permite definir múltiples métodos con el mismo nombre,
// pero con distintos parámetros.
// Puede aplicarse a constructores, métodos y operadores,
// como muestra el presente ejemplo, que al ejecutarlo visualiza
// el valor 18 que es el quinto elemento de una matríz.
////////////////////////////////////////////////////////////
#include
#pragma hdrstop
#include "MatrizSobrecarga.H"
USERES("Sobrecarga.res");
USEUNIT("MatrizSobrecarga.cpp");

Qué es esto.??SOBRECARGA

WINAPI WinMain(HINSTANCE, HINSTANCE, LPSTR, int)
{
//////////////////////////////////////////////////////
// Notar que tanto podemos asignar Tabla[5] = 18
// u obtener AnsiString(Tabla[5]) el valor de un
// elemento de la matríz sin usar dos métodos diferentes
//////////////////////////////////////////////////////
TMatriz Tabla(20);
Tabla[5] = 18;
ShowMessage(AnsiString(Tabla[5]));
return 0;
}

///////////////////////////////////////////////////////
// Sin aplicar sobrecarga esta función sería
// Notar la necesidad de las dos funciones
// Tabla.Asigna(5, 18) y AnsiString(Tabla.Valor(5))
//////////////////////////////////////////////////////
// WINAPI WinMain(HINSTANCE, HINSTANCE, LPSTR, int)
// {
// TMatriz Tabla(20);
// Tabla.Asigna(5, 18);
// ShowMessage(AnsiString(Tabla.Valor(5)));
// return 0;
// }
///////////////////////////////////////////////////////

DefinicionesMatrizSobrecarga.h
///////////////////////////////////////////////////////
// C++ Builder Wilo Carpio
// SOBRECARGA: MatrizSobrecarga.h
///////////////////////////////////////////////////////
#ifndef MatrizH
#define MatrizH

///////////////////////////////////////////////////
// Definición del tipo de objeto TMatriz, que nos
// permitirá crear matrices de tamaño dinámico
///////////////////////////////////////////////////
class TMatriz
{
private:
///////////////////////////////////////////////////////
// Puntero a la zona de memoria donde estará la matriz
///////////////////////////////////////////////////////
int * Elementos;

//////////////////////////////////////////////////////
// Número de elementos de la matriz
//////////////////////////////////////////////////////
int NumElementos;

public:
/////////////////////////////////////////
// El constructor asignará la memoria
/////////////////////////////////////////
TMatriz(int Num);

////////////////////////////////////////////////
// Método para obtener le valor de un elemento
// Notar que este operador solo toma un parámetro
// y devuelve un múmero entero
////////////////////////////////////////////////
int & operator[](int Num);

//////////////////////////////////////////////
// El destructor liberará la memoria asignada
//////////////////////////////////////////////
~TMatriz();
};
/////////////////////////////////////////////////////////
// Sin aplicar sobrecarga esta declaración sería
// Notar que esta tiene los métodos Asigna()
// que permite asignar un valor a un elemento
// y Valor() que devuelve el valor actual del
// elemento que se indique
/////////////////////////////////////////////////////////
// class TMatriz
// { private:
// int * Elementos; // Puntero a la zona de memoria donde estará la matriz
// int NumElementos; // Número de elementos de la matriz
// public:
// // El constructor asignará la memoria
// TMatriz(int Num);
// // Método para asignar un valor a un elemento
// void Asigna(int Num, int Valor);
// // Método para obtener le valor de un elemento
// int Valor(int Num);
// // El destructor liberará la memoria asignada
// ~TMatriz();
//};
///////////////////////////////////////////////////////

#endif

MétodosMatrizSobrecarga.cpp
///////////////////////////////////////////////////////
// C++ Builder Wilo Carpio
// SOBRECARGA: MatrizSobrecarga.cpp
///////////////////////////////////////////////////////
#include
#pragma hdrstop
#include "MatrizSobrecarga.h"

///////////////////////////////////////////////////////
// Convervar el número de elementos y asignar la memoria
///////////////////////////////////////////////////////
TMatriz::TMatriz(int Num)
{
NumElementos = Num;
Elementos = new int[NumElementos];
}

///////////////////////////////////////////////////////////
// Este método solo devuelve el valor de su parámetro.
// Osea devuelve el valor de una referencia y no el valor
// del elemento, modificamos así el contenido
///////////////////////////////////////////////////////////
int & TMatriz::operator[](int Num)
{
return Elementos[Num];
}

///////////////////////////////////////////////////////
// Liberar la memoria asignada
///////////////////////////////////////////////////////
TMatriz::~TMatriz()
{
delete [] Elementos;
}

///////////////////////////////////////////////////////
// Sin aplicar sobrecarga todo esto sería:
///////////////////////////////////////////////////////
// TMatriz::TMatriz(int Num)
// { NumElementos = Num; // Convervar el número de elementos
// Elementos = new int[NumElementos]; // y asignar la memoria
// }
// void TMatriz::Asigna(int Num, int Valor)
// { Elementos[Num] = Valor;
// }
// int TMatriz::Valor(int Num)
// { return Elementos[Num];
// }
// TMatriz::~TMatriz()
// { // Liberar la memoria asignada
// delete [] Elementos;
// }
///////////////////////////////////////////////////////

#pragma package(smart_init)