Programación 2

Unidad 1

Recursión

*1. Conceptos

Proposición Oración (V/F)

Esquema Proposicional

Oración

-Contiene una variable

-Var. tiene un dominio

-Al reemplazar x por un valor de su dominio la convierte en proposición

*Generador de proposiciones

Ejemplos:

- (no es una proposición)

P[x]=El día x hay clases de programación ll …X pertenece {lunes, martes, miércoles, jueves}

Q[x]=x es menor que 5 ...X pertenece {1,2,3}

R[n]=cuanto es mayor que n …N pertenece {4,3,2,1}

N números naturales es igual a n multiplicado por su sucesor dividido entre 2

Q[x]=x<5 x pertenece {1,2,3} - Valido

R[n]=4>n …n pertenece {1,2,3,4} - Satisfacible

S[n]=1+2+3+4…+n = n(n+1) /2 …n pertenece |N

T[x]=El día x hay clases de prog. 2 … x pertenece {lunes, sábado, miércoles} - No satisfacible

*Estado Proposicional

-No satisfacible … (Si todas las prop. Son Falsas)

-Satisfacible … (Si al menos una prop. Es Falsa y una Verdadera)

-Valido … (Si todas las prop. Son verdaderas)

P.I.C
Principio de inducción completa

Probar que P[1] es verdadero

i) P[1] La primera proposición

S[n]=1+2+3+4…+n = n(n+1) /2 …n pertenece |N

1=1(1+1) /2

=1(2) /2

=2/2

| 1 = 1 | Verdadero

ii) P[2] La segunda proposición

S[n-1]=1+2+3+4…+(n-1) = (n-1)(n) /2 Suponemos que es Verdadero

| 1+2+3+…|+n = n(n+1)/2

(n-1) n/2 + n =

(n-1)n + 2n
------------------------ =
N

n2-n+2n
----------------------- =
2

n2+n
------------ =
2

n(n+1)
------------ =
2

| n(n+1)/2 = n(n+1)/2 |

1+2+3+4 = 4(5)/2

10=10

| Mientras más aprendo tecleo menos |

Ejemplo:

Escribir una función que devuelva la suma de los primeros n números naturales.

//---------------------------------------------------------------------------

int suma(byte n)
{

return n*(n+1)/2;

void __fastcall TForm1::Button1Click(TObject *Sender)

{
Label1->Caption=suma(StrToInt(Edit1->Text));
}
//---------------------------------------------------------------------------

*2. Proceso Recursivo

Un proceso es recursivo si entre sus instrucciones ay al menos una,
que es una llamada al mismo proceso.

void Recursivo()
{
ShowMessage("Hola");
Recursivo();
ShowMessage("Mundo");
}

Proceso recursivo bien definido

Un proceso recursivo se dice que está bien definido si cumple que:

a) Caso base: Tiene al menos una situación en la que la llamada recursiva no se hace.

Se debe resolver el problema para el primer valor del dominio de la variable de recursión.

b) Caso general: Si se hace la llamada recursiva esta debe hacerse de forma que se aproxime
al caso base.

Suponga que ya hay un proceso que hace lo mismo que quiere hacer, pero lo hace para un
dato menos. Utilizando ese proceso terminar el trabajo.
Pasos a seguir para escribir un algoritmo recursivo.

-P1 Determinar la variable de recursión.

Es la var. Que representa/indica la cantidad de datos o proesos.

-P2 Determinar el dominio de la variable recursiva

Dn=D[tipo de dato] intersección D[Conteo problema]

-P3 Escribir el algoritmo

|Caso base|Caso gral|

Ejemplos:

1)Escribir una función que devuelva una cadena con los primeros N números naturales.

Ej. Si N = 5 => “1,2,3,4,5”

VR= n (cant de numeros)

Dn = byte [0,255] intersección [0,infinito]

Dn = [0,255]

String Cadena(byte n)
{ String Pal;
if (n==0)
{
Pal="";
}else
{
if (n==1) {
Pal=Cadena(n-1)+n;
}else{
Pal=Cadena(n-1)+","+n;
}

return Pal;

}
2) Factorial
int factorial(byte n)
{ int fact;

if (n==0)
{
fact=1;
}else
{
fact=n*factorial(n-1);
}
return fact;
}
Algoritmos con números
1)Escribir una función que devuelva la suma de los dígitos de un numero

Ejemplo:
N=variable conceptual
X=374362 => 25
P0) E:Num.Nat.Gr. S:Num.Nat.Pe
P1) VR=n (cant de dígitos de x)
P2) Dx=[0,2exp(32)-1]
Dx=[0,4294967295]
Dx=[0,1,2,3,….,100,……..42567876543]
Dn={1,2,3,4,5,6,7,8,9,10}
Dn=[1,10]interseccion[1,infinito[
P3) Caso base
Caso general
| X=37436|2
23+2=25
unsigned char Suma( int n)
{ unsigned long int a,b;

if (n<10)
{
a=n;
}
else
{
b= n % 10;
a=b+Suma(n/10);
}
return a;

int _tmain(int argc, _TCHAR* argv[])

{ unsigned long int a;

cout<<"Escciba un numero \n";

cin>>a;
cout<<int(Suma(a))<<'\n';
system("Pause") ;
cin>>a;
return 0;
}

2)Escribir una función que devuelva la suma de los dígitos impares.

3)Escribir una función que devuelva el digito menor de un número.

Escribir un proceso para eliminar los dígitos pares de un numero
Ej:
P0) x=5432345=5335
P1) VR=n(cant. De digitos de x)
P2) Dn=[1,10]interseccion[1,infinito[
Dn=[1,10]
P3) Caso base
impar X=7 => x=7
par x=4 => x=0;

Caso general
X=3456|7 (impar)
X=35

Escribir un proceso para separar en 2 variables los dígitos pares e impares de un número.
P0) X=12345 => x1=24 X2=135

Escribir un proceso para eliminar los dígitos primos de un numero

P0) X=123456=1235
P1) VR=n de dígitos
P2) Dn= [1,10]intersección [1, infinito [
P3) Caso base
Primo => x=0
Normal => x=x
P4)

Tarea:
Leer sobre tipos de datos en c++
Bloques en estructuras de control
Estructuras discretas (proposiciones, tablas de verdad)
2° principio de inducción

También se puede demostrar que P[n] es válido, si logramos probar que

i) P[1] and P[2] and …… and P[m] es V

ii) Suponiendo que P[k] es V (hipótesis) para m< |< <n probar que P[n] también lo es

Aplicando PIC a proceso recursivo bien definido

Casos base se debe resolver el problema para los primeros m casos base, en todas sus situaciones
(sin recursión)
Caso general suponga que ya hay un proceso que hace lo mismo que queremos hacer (hipótesis),
pero no lo hace todo, lo hace para k (n<k<n)

Usando ese proceso se deberá completar el trabajo.

Determinación del número mínimo de casos base (m)

K=n-1

K=n-2
K=n/2

-----------------------------------------------------------------------------------------------------------------------------------

Algoritmos con cadenas

Estándar
C | C++(android) | C++builder
Vector de | string | string Unicode
Caracteres | length() | ApsiString ASCII
X|H|o|l|a|\0| | erase(p,n) | Delete(p,n)
Strcpy | |
Strcat

1)Escribir una función que devuelva la cantidad de “n” que hay en una cadena
|-------------------| n
Ej.: x=” Bonita mañana”

P0) E: una cadena S:número natural pequeño

P1) VR=cantidad de caracteres (longitud de cadena)
P2) Dn=[0,255] intersección [0,infinito[
Dn=[0,255]

a) K=n-1  Menos el primer caracter

 Menos el último
2)Funcion que devuelva la cantidad de espacios de una cadena
Ej.: x=Hola que tal

P0) Entrada: Cadena Salida: Natural pequeño

P1) VR=n (longitud de x)
P2) Dn= [0,255] intersección [0, infinito]
Dn= [0,255]

P3) K=n-1  Menos el primero

Menos el ultimo

K=n-2 menos los dos primeros

menos los 2 ultimos
menos el primer y ultimo digito

P4) x=”Hola que tal”

K=n/2 Lado izq. Mas corto

Lado der mas corto

N1=n/2; (lado corto )

N2=(n+1)/2; (lado largo)

Wchar_t String UNICODE

Char AnsiString ASCII

Algoritmos con vectores

Max=cte. que representa la cantidad de casillas reservadas

NCantidad de x elementos en el vector

Cantidad de datos a procesar

Parámetros para procesamiento de vectores

N=Cantidad de datos a procesar
A=Posición inicial
B =Posición final

Uno de ellos es calculable

Combinaciones posibles
. n, a = 0 b= n-1
. a,b n=b-a+1
. a,n b=n+a-1
. b,n a=b-n+1

Ejercicios
1)Cargar randomicamente un vector con n datos

Can E: v(vector) S:v

N (cant de elementos)
P0)
P1) VR=n (cant de elem)
P2) Dn= [0,255] intersección [0, infinito [
Dn= [0,255]
P3) K=n-1 (menos el primero)
Caso base
N=0
4)escribir un proceso para mover el mayor al final de un vector

(usando método burbuja)

Ej.:

// V |7|3|6|8|4|2|
// V |3|6|7|4|2|8|

P0) E:vector1 S:Vector2

 n (cant de elementos)
a,b (pos inicial, pos final)

P1) VR=n(cant. de elementos)

P2) Dn=[0,255] intersección [0,infinito[
Dn=[0,255]
P3) (Burbuja) k=n-1 (menos el ultimo)

V |7|3|6|8|4|2|

V |3|6|7|4|8|2| (8>2) v o f

Caso base
N=0 => nada
N=1 => nada

Debugger

F4 = Ejecuta el código hasta donde se encuentra el cursor

F7=Ejecuta una instrucción (si es proceso ingresa)
F8=Ejecuta una instrucción (si es un proceso, lo ejecuta)
Ctrl+F9=compilar
F9=compila y ejecuta el programa
(modo debug) F9=continua la ejecución del programa

Técnica para rastreo de algoritmos recursivos

Método del yoyo
1)Se ejecuta el programa hasta la primera línea del proceso que se quiere rastrear.
2)ejecutar paso a paso (f7/f8) hasta la llamada recursiva
3)ejecutar la llamada recursiva (f7)
4)repetir pasos 2 y 3 hasta finalizar

Jose miguel siles (crack)

Algoritmos con matrices

M=cant de columnas
N=cant de columnas
Ma = fila inicial
Mb=fila final
Na=columna inicial
Nb=columna final

N=nb-na+1
M=mb-ma+1

Tipos de hipótesis
K=m-1 , n-1
K= m-2 , n-2
K=m/2 , n/2

56 posibles soluciones

K=m*n (cant. de casillas total)

7 posibles soluciones adicionales

Procesando la matriz como si fuera un vector
28 posibles soluciones adicionales
Ejercicios:
1)escribir un algoritmo para cargar una matriz de la sgte forma:

A={ {1,2,3,4,5},{6,7,8,9,10},{11,12,13,14,15},{16,17,18,19,20},{21,22,23,24,25} }

Na=0 ma=0 mb=m-1 nb=n-1

2)mostrar una matriz recursivamente

3)cargar una matriz cuadrada

Ejemplo: el numero 5 del vector (elemento 3) k=8/4
Residuo=0(j) Div=2(i)  2[i][j]=5

1)Cargar automaticamente una matriz

V=| | | | | | | | | |

1)hipotesis (ya hay proceso que llena el vector) (usando n-1)

2) v[n-1]=random

A[(n-1)%n][(n-1]/n]

2)Dada una matriz ordenada, excepto la ultima casilla, ordenar (Colocar el ultimo dato en su
llugar)
 Unidad 2
Fundamentos de Algoritmia

1.Conceptos

-Algoritmo

E P S
n=cantidad de datos a procesar
(tamaño de la entrada)

-Computador
Dispositivo electrónico capaz de procesar una gran cantidad de datos en poco tiempo.

X=2*n+5^2*y;
(Adán Lovenaca)

-Eficaz, Eficiente

Desempeño de los algoritmos

Los factores que pueden afectar el desempeño de los algoritmos son:
-Hardware
Procesador,memoria,disco duro
-Software
Sist. Operativo, compilador, Etc.
-Algoritmo

Complejidad

-Complejidad temporal. Un cálculo es más complejo que otro si su ejecución requiere más tiempo
-Complejidad espacial. Conforme aumenta la complejidad de un cálculo más espacio de
almacenamiento necesita para su ejecución

-Algoritmia

2.Tiempo de Ejecución

2^n
T(n) Te de ene
La cantidad de instrucciones ejecutadas por el algoritmo hasta la solución del problema
3.Grado de complejidad de un algoritmo
O(n) La O grande de N
Es la familia de funciones a la que pertenece la función de tiempo de un algoritmo
Ej:
TA(n)=2n+7
TA(n)=n^2

Tarea: leer cap 1, cap 2, cap3

Grado de complejidad

-Logaritmicos
-N logaritmicos
-Polinomiales{ Lineales,cúbicos,….,etc
-Exponenciales

Sigma(n)
Ej. O(n) Headsort=n*log(n)
O(n) Burbuja = n^2
T(n) Tiempo de ejecución de un algoritmo

1) n!=1*2*3*….*n

n!= { 1 si n=0
{ n*(n-1)! Si n>0

+ + + + + + +
Fibo(n)= 0 , 1 , 1 , 2 , 3 , 5 , 8 …

2) Fibo(n) = { 0 si n=1
{ 1 si n=2
( Fibo(n-2)+Fibo(n-1)

N T(n)
27 1 ms

30 4 ms 2
31 8 1.5 n-27
32 12 1.583 Tfibo(n)=media=1.63 (aprox)
33 19 1.895 o(n)=Exponencial
34 36 1.416
35 51 1.588
36 81 1.617
37 131 212/81 1.618
38 212 343/212 1.617
39 343 553/343 1.611

con la formula
40 553 ms

50 75913 ms 75913/1000/60 1 min , 265 seg

80 468078013753 468078013753/1000/60/60/60 2039 dias

Tfibo2(n)= 5*n (mas o menos)
O(n)=lineal

Alternativas ante un algoritmo exponencial

-Optimizar el algoritmo
-Algoritmos de Aprox.
-Supercomputadoras
-Cambiar técnica de algoritmos hacer Algoritmos Paralelos
Formas de cálculo de T(n)
*Algoritmos iterativos
El cálculo se hará mediante tablas de conteo .
Se contara la cantidad de veces que se ejecuta cada instrucción de cada línea
Luego se suma el tiempo de cada línea.
*Algoritmos recursivos
El calculo se hará mediante ecuaciones de recurrencia las mismas que se resolverán por el método
de iteraciones.

Ejercicios:

*Algoritmos constantes
T(n)=K
1)
Void Swap(int &x, int &y)
L t
{ int z;
1 1
1 z=x;
2 1
2 X=y;
3 1
3 y=z;
} Tswap(2)=3

2)Función que devuelva el mayor de los elementos de un vector ordenado

int Mayor(int v[], Word n)

{
return v[n-1];
}
Tmayor(n)=1

3)Función que devuelva la suma de los primeros n números naturales

Ej: n=71+2+3+4+5+6+7=28

* word Suma(byte n) { return (n>0)? n+Suma(n-1) : 0; } Tsuma(n)=n

* word Suma(byte n){ return n(n+1)/2; } Tsuma(n)=1

*Algoritmos lineales
T(n)=An+B procesan un conjunto de datos
|----------------|
n
--------------- -Un solo recorrido
-------------- -Cada dato es revisado una sola vez
-----------
------ ----
Etc.
1)Funcion que devuelva las suma de los elementos de un vector

a) int Suma(int v[], word n)

{ int I,s; Calculo por deduccion
1 S=0;
L T
2I=0;
1 1 n 1 2 3 4… n
3While (i<n){
2 1 T(3) 2 3 4 5..n+1
4 S=s+v[i];
3 N+1 T(4) 1 2 3 4 n
5 I++;
} 4 N T(5) 1 2 3 4 n
6Return s; 5 n
} 6 1
Tsuma(n)=3n+4
Comprobacion

Tsuma(n)03n+4
N=4  3(4)+4
= 16 instrucciones

b) int Suma(int v[], word n)

L t n 1 2 3 4 n
{ int I,s;
1 1 T(2)A 1 1 1 1 1
1 s=0;
2 (1+n+1+n)=2n+2 T(2)B 2 3 4 5 n+1
2 for (i=0; i<n; i++){
A B C 3 N T(2)C 1 2 3 4 n
(tiene 3 iteraciones 4 1 T(3) 1 2 3 4 n
en orden descendente [CBA] ) Tsuma(n)=3n+4
1 S=s+v[i];
}
4 Return s;
}

c) int Suma(int v[],Word n)

{
L T n 1 2 3 N
1 Return (n>0) ? v[n-1]+Suma(v,n-1) : 0 ;
} 1 N+2 T(1) 2 3 4 N+1
T(2) 1 2 3 n
Tsuma(n)=n+3
d) int Suma(int v[],word n)
{ int n,s;
If (n==0){
S=0;
}Else{
S=suma(v,n-1);
S=s+v[n-1];
}
Return s;
}

*Calculo de tiempo en algoritmos recursivos

Paso 1
Establecer las ecuaciones de recurrencia

Tsuma(n)={ 3 si n=0 Caso base

{4+Tsuma(n-1) Caso general

Paso2
Resolviendo las ecuaciones recurrentes mediante iteraciones

I=0 Tsuma(n)=4+Tsuma(n-1)

1 =4+4+Tsuma(n-2)
=8+Tsuma(n-2)
2 =8+4+Tsuma(n-3)
=12+Tsuma(n-3)
3 =12+4+Tsuma(n-4)
=16+Tsuma(n-4)
. .
. .
. .
I Tsuma(n) =A+Tsuma(0);

Paso 3
Calculo de constantes
Paso 4
Determinación del número de iteraciones
(antes de llamar al caso base)

Paso 5
Sustitucion de i en las constantes

A=4i+4
A=4(n-1)+4
A=4n-4+4
A=4n

Paso 6
Sustitucion de las constantes en la ecuación principal (no recurrente)

Tsuma(n)=A+Tsuma(0)

Tsuma(4n+3) es igual a esto

Tsuma(n)={ 3 si n=0 Caso base
{4+Tsuma(n-1) Caso general

Comprobar que sale lo mismo

e) int Suma(int v[],word n)
{ int n,s;
If (n==0){
S=0;
}Else{
S=suma(v,n-1)+v[n-1];
S=s+v[n-1];
}
Return s;
}
Algoritmos logarítmicos

1) Procesa un dato
2) Obtiene la mitad
3) Repite pasos 1 y 2 hasta que quede solamente 1 dato

Ej:

bool BusBin(int v[],int a,int b, int x)

{ bool hallado;
Int c,n; (2^1-1) (2^2)-1
MC PC N 1 3 7 15 N
1 n=b-a+1; hallado=false; X esta X No está
2 while (a<=b && ¡(hallado)){ T(2) 2 3 4 5 T
en en el vec
3 c=(a+b)/2; V[n/2] T(3) 1 2 3 4 t-1
4 if (x==V[c]){ 1 2 2
5 hallado=true;
2 2 Log2(n+1)+1
6 }else if (x<v[c]){
7 B=c-1; 3 1 Log2(n+1) n=(2^t-1)-1
}else{ 4 1 Log2(n+1) n+1=(2^t-1)
8 A=c+1; 5 1 0 log2(n+1)=log2(2^t-1)
} 6 0 Log2(n+1) log2(n+1)=2*log2(t-1)
9 return hallado; log2(n+1)=t-1
7 0 Log2(n+1)/2
} t=log2(n+1)+1
8 0 Log2(n+1)/2
9 1 1

T(n)=8 T(n)=5*log2(n+1)+4
Probando los resultados
TBuBin(x=7;n=15)=5*log(15+1)+4
=5(4)+4
=24 instrucciones
Bool BusBin(int v[],int a, int b,int x){
Int n; bool hallado;

N=b-a+1;
If (n==0){
Hallado=false;
}else{
Int c=(a+b)/2;
If (x==v[c]){
Hallado=true;
}else if (x<v[c]){
Hallado=BusBin(v,a,c-1,x);
}else{
Hallado=BusBin(v,c+1,b,x);
}
}
}

Paso 1
Establecer las ecuaciones de recurrencia
{4, si n=0 cb
{------------------------------------------------
TBusBin(n)={6 mc cg
{7+TBusBin(n/2) pc

Paso2
Resolviendo las ecuaciones recurrentes mediante iteraciones
I=0 TBusBin(n)=7+TBusBin(n/2)
=7+7+TBusBin(n/4)
I=1 =14+TBusBin(n/4)
=14+7+TBusBin(n/8)
I=2 =21+TBusBin(n/8)
=21+7+TBusBin(n/16)
I=3 =28+TBusBin(n/16)
. . .
. . .
i-1 =A-7+TBusBin(1)
i =A+TBusBin(0)

Paso 3
Calculo de constantes

I 0 1 2 3 ……………….i
A 7+7+7+7+7+7……………….+7
Paso 4
Determinación del número de iteraciones
(antes de llamar al caso base)

N=2^i+1
Log2(n)=log(2^i+1)
Log2(n)=log2(2)(i+1)
Log2(n)=i+1
(antes de la iesima (i-1) )
i=log2(n)

Paso 5
Sustitucion de i en las constantes
A=7+7i

A=7+7log2(n)

Paso 6
Sustitucion de las constantes en la ecuación principal (no recurrente)

TBusBin(n)=A+TBusBin(0)
=7+7los2(n)+4

TBusBin(n)=7log2(n)+11
Algoritmos cuadraticos

n
|-------------------------------------|
----------------------------------- |
----------------------------------- | n
----------------------------------- |

T(n)=An^2+Bn+C

Variaciones

|-------------------------------------|
--------------------------------- |
------------------------------- | n
--------------------------- |

|----|
------ |
---------- | n
-------------- |

T(n)=(An^2)/2+(Bn)/2+C

Ejemplo:
Algoritmo de ordenamiento

Selection short

Void Selection(int v[],Word n)

{
While ()
{
P=posmayor(v,n);
X=v[p];
V[p]=v[n-1];
V[n-1]=x;
n--;
}

}
TposMayor(n)=[3n+1,4n]
 Unidad 3
Diagrama de clases
Clases
Relaciones {-Herencia
{Asociación
{Agregación
{Composición
{Dependencia

//insertar imagen Diagrama de clases

*clases
Tipos de clases
Clases definidas por sus atributos
-Tienen varios atributos
-No almacenan datos (además de los atributos)
-Casi no tienen métodos visibles
Ej:
Fecha Tiempo
Dia Hora
Mes Minuto
Año Segundo
ToStr ToStr

Clases definidas por sus operaciones (Estructura de datos)

-Tienen pocos atributos
-Almacenan muchos datos
-Lo que hacen sus operaciones es lo que define a la clase

Pila Cola
Tope Frente
Atras
Vacia
Vacia
Llena
Llena
Meter
Meter
Sacar
Sacar
El dato a sacar El dato a sacar es
Es el último en ser ingresado el primero en entrar
Clases de servicio
-No tienen atributos
-No almacenan datos
-Solo tienen métodos
Ej:

Mat

Log
Sin
Cos
Tag
Sqrt
Pow

Notación
Dividido en 3 partes

Nombre (singular)
Atributos
(Nombre Completo)
Metodos ()

*Métodos: Son las cosas que pueden hacer los objetos de la clase (de forma individual)
Tipos de Métodos
a) Por su relación con sus datos
-Constructores
En c++ el destructor tiene el nombre de la clase
Se encargan de:
. Reservan espacio de memoria para los objetos de la clase (Compilador -SO)
. Inicializar los atributos del objeto
*const. De oficio
El implementador es el que decide los datos iniciales
*const. De copia
Se inicializa con datos de otro objeto de la misma clase
*const. Parametrizado
Inicializar con datos recibidos a través de parámetros.
-Destructor
Liberar la memoria ocupada por el objeto.
(Se debe programar si el objeto almacena otros datos además de los atributos)

En c++ el destructor tiene el nombre de la clase negado (¡constructor)

-Modificadores
Permiten modificar los datos de los atributos previa validación.
Debería haber un modificador por cada atributo

-Selectores
Son funciones que devuelven el contenido de los atributos
Debería haber un selector por cada atributo

b) Por su alcance

Privado/private
Son aquellos que solo los miembros de la clase pueden acceder
Ej. Pivotear. (cualquier método auxiliar)

Protegido/protected
Solo los miembros de la clase y sus herederos tienen acceso
Ej. Hms de la clase tiempo

Publico/public
Son aquellos accesibles por todos
Ej. Ordenar, buscar….

c) Por su visibilidad
No visibles
- Son aquellos métodos que siempre se deben programar en una clase (obvio) por lo tanto No se
debe escribir en el diagrama

Estos métodos son: constructores, destructor, modificadores, ni selectores principales.

Tiempo
Hora
Minuto
Segundo
ToStr
Visibles
Son otras acciones que de manera explícita se quiere indicar que hacen los objetos de la clase.
Ej. ToStr de la clase tiempo y fecha
 Tiempo
*Atributos: Son las características que describen a los objetos
de una clase.
Hora
Se reflejan en el diseño. Minuto
Ej. Hora, minuto, segundo de la clase tiempo Segundo
ToStr
Analista/Dis.

Implementador

Usuario
Programador

Campo/Field
Son variables en las que el implementador guardara los datos de los atributos. El guardado será:
1 Atr.  1 campo byte h,m,s;
N Atr.  1 campo Word hms;
1 Atr.  n campos Cardinal cod1, cod2;
Propiedad/Properties
Son pseudovariables con las que el implementador creara abstracciones de los atributos al usuario
de la clase.
(pseudovariable: es un tipo de implementación de variable {no es variable} )

throw new Exception("Error:");

__property int Hora={read=Funcion,wrtite=Funcion}
Implementación
1ra parte Implementación de una clase simple

2da parte Aumentar la implementación (sobrecarga, operadores)

3ra parte Ampliar la implementación (relaciones entre clases)

Tiempo
Hora
Minuto
Segundo
ToStr
Creando un Modulo

Definiciones Implementación de los métodos

//constructores
*de oficio ()
*de copia (const Clase &)
*parametrizado
//modificadores

//selectores
.h .cpp

Bitwise

Creando un proyecto
Proyecto

Modulo Modulo del UTiempo

formulario
Principal
Grabando el
Proyecto
-Nombre del módulo del formulario
.h .cpp .dfm
-Nombre del módulo principal
.h
-Nombre del proyecto
.cbproj

Agregando módulos a un proyecto

*Addfile To Project
#include “utiempo.h” en Modulo del formulario .h

Sobrecarga/Overload
*Un método o proceso para realizar más de una tarea
*Son varios procesos que tienen el mismo nombre, pero se diferencian por:
 -Tipo de dato de los parámetros
-Cantidad de parámetros
Tipos de operadores
-De funciones(procesos)
-De operadores Ej. + (suma)(concatena)
a+ b
[Los operadores se implementan como funciones]
Estr. OOP
+(a,b) a.+(b)
Operadores

Aritméticos
+ -
*/
%
Relacionales
> <
>= <=
== ¡=
Lógicos
¡ && ||
(~) (and) (or)
Asignación
=
Otros
[],&,|,*,<<,>>,etc.

Relaciones entre clases

*Herencia
Permite crear clases a partir de otra(s) ya existentes.
-Herencia simple
Cuando hereda de una sola clase

Base Superclase Padre

t = {10:11:12}
Tiempo
Hora
Minuto
Segundo
Virtual ToStr

Derivada Subclase Hijo

t = {10:11:12:14}
TiempoC
Centesima

ToStr
Overwrite/Redefinición
Consiste en que una clase derivada podrá redefinir (hacer su propia implementación) un método
heredado.
Método virtual
Es un método definido e implementado por una clase (base), que podrá ser redefinido por sus
derivadas

-Herencia múltiple
Puede heredar de más de una clase.
Ej.
Base Superclase Padre
t = {10:11:12}
Tiempo Fecha
Hora Día
Minuto Mes
Segundo Año
Virtual ToStr Virtual ToStr

Derivada Subclase Hijo

t = {10:11:12:14}
TiempoC FechaTiempo
Centesima

ToStr ToStr
Principio de sustitución
Allí donde se espera un objeto de una clase (base) se puede recibir objetos de esa clase o de
cualquiera de sus derivadas.
Ligadura
Se refiere a la forma en que una variable es asociada a un objeto.
-Ligadura estática/static Binding
La variable y el objeto están asociados en el momento de su definición
-Ligadura dinámica
Una variable podría instanciar con 0,1 o más objetos (aunque no al mismo tiempo)

Polimorfismo (investigar)

Generalización/especialización

Especialización
Primero se crea la clase principal, luego la derivada
Generalización //como la factorización en matemáticas
Primero la clase derivada, luego la principal
*Se identifican los atributos
*luego los métodos

Línea Rectángulo Triangulo Circulo

Punto1 Punto Punto Punto
Punto2 Base Base Radio
Color Altura Altura Color
Color Color
Mostrar Mostrar Mostrar Mostrar
Área Área

Figura

Punto
Color
Mostrar

Línea Rectángulo Triangulo Circulo

Punto1 Base Base Radio
Altura Altura

Área Área

Relaciones entre clases

*Herencia

Hereda los atributos y métodos de la clase

*Asociación

Rol
Papel desempeñado por los objetos relacionados
Cardinalidad
- 1-1 (uno a uno)
- 1-n (uno a muchos)
- m-n (muchos a muchos)
Participación
- Total (Todos)
- Parcial (Algunos)
*Composición

Todo Partes Cardinalidad

Rol

-Dependencia existencial
El elemento dependiente desaparece al destruirse el que lo contiene y, si es de cardinalidad 1 es
creado al mismo tiempo.

*Agregación

Contenedor contenido

Si se puede meter y sacar es agregación

*Dependencia
Clase
De
Servicios

Significa que una clase necesita de otra para prestar sus servicios