15. Paradigma Orientado a Objetos

Antes de comenzar a revisar los ejercicios sobre Clases, me gustaría introducir al paradigma Orientado a Objetos. Personalmente creo que uno de los grandes problemas en la enseñanza del paradigma consiste en que no se define de manera concisa lo que el paradigma comprende. Al respecto he decidido actualizar un tutorial que escribi en mayo del 2001 pero que considero que será de gran ayuda sobre todo para aquellos que se inician en este paradigma.

http://www.paginasprodigy.com.mx/sanluga/PARADIGMA_OO_2_0.doc

Después de revisar estos conceptos entonces sugiero comenzar a revisar los siguientes ejercicios enfocados a reforzar y aumentar el conocimiento sobre el paradigma:

1. Diseñando Clases

2. Controlando el acceso a las Clases

3. Creando propiedades y métodos estáticos

4. Sobrecarga de operadores

5. Herencia

6. Clases Abstractas

7. Creando interfases

8. Delegados

14. Clase ArrayList

Como pudimos observar en el tema anterior la clase array es una clase abstracta muy poderosa y que requiere de practica para poder dominarla, sin embargo, existen cierto tipo de problemas que requieren de arreglos que tengan posibilidades de cambiar de tamaño de manera dinámica.

La clase ArrayList nos permitirá realizar este tipo de operaciones además de otras y de forma mucho más amigable, por lo que generalmente este objeto es muy utilizado para implementar arreglos mucho más poderosos, incluso a partir del punto 6 se muestra algunas técnicas avanzadas que nos permiten utilizar ArrayList con Arreglos managed.

1. Declarando e inicializando ArrayList unidimensionales de longitud variable
http://www.paginasprodigy.com.mx/sanluga/arraylist1.txt

2. Accesando a los elementos de un ArrayList unidimensional de longitud variable
http://www.paginasprodigy.com.mx/sanluga/arraylist2.txt

3. Operación de búsqueda en un ArrayList unidimensional de longitud variable
http://www.paginasprodigy.com.mx/sanluga/arraylist3.txt

4. Eliminando valores de un ArrayList unidimensional de longitud variable
http://www.paginasprodigy.com.mx/sanluga/arraylist4.txt

5. Operaciones utiles de un ArrayList
http://www.paginasprodigy.com.mx/sanluga/arraylist5.txt

6. Declarando e inicializando ArrayList bidimensionales de longitud variable
http://www.paginasprodigy.com.mx/sanluga/arraylist6.txt

7. Accesando a los elementos de un ArrayList bidimensional de longitud variable
http://www.paginasprodigy.com.mx/sanluga/arraylist7.txt

8. Operación de búsqueda en un ArrayList bidimensional de longitud variable
http://www.paginasprodigy.com.mx/sanluga/arraylist8.txt

9. Eliminando valores de un ArrayList bidimensional de longitud variable
http://www.paginasprodigy.com.mx/sanluga/arraylist9.txt

13. Arreglos managed

Voy a tratar de explicar uno de los temas más escabrozos que tiene VC++ y que se refiere a el uso de arreglos administrados. Ahora los arreglos los debemos considerar de dos tipos:

Nativos: Son aquellos que soliamos utilizar en C/C++ y que iniciabamos con alguna declaración como esta:

int miArreglo[5];

Managed: Son aquellos que son administrados por el CLR y que cuentan con las facilidades descritas en el apartado de código managed.

array ^ miArreglo = gcnew array(5);

Es posible utilizar digamos un mixed mode, es decir podríamos revolver en un momento dado arrglos nativos con arreglos managed pero el resultado sería un pobre desempeño de nuestras aplicaciones. Encontré un foro en donde revisaban esta cuestión, esta interesante:

http://forums.microsoft.com/MSDN/ShowPost.aspx?PostID=2320388&SiteID=1

Bien pues, como lo apunte desde el inicio, nos vamos a centrar en managed mode así bien todos los ejemplos que siguen tienen un enfoque de arreglos administrados y ojo, debes tener mucho cuidado con los ejemplos que llegues a encontrar en Internet puesto que muchos utilizan sintaxis promovidas en frameworks anteriores, así bien, la sintaxis que presento en este taller, al menos en este punto funciona para Visual Studio 2008, es decir .NET 3.5, si Microsoft llega a sacar otro framework deberíamos revisar que sirve y que de plano ya descontinuo (si, ese es el relajo). En fin vamos a revisar los ejemplos:

1. Declaración e inicialización de un Arreglo unidimensional y de longitud fija
http://www.paginasprodigy.com.mx/sanluga/arreglo1.txt

2. Accesando a los elementos miembro de un arreglo unidimensional y de longitud fija
http://www.paginasprodigy.com.mx/sanluga/arreglo2.txt

3. Operaciones Utiles en los arreglos unidimensionales de longitud fija

http://www.paginasprodigy.com.mx/sanluga/arreglo3.txt

4. Declarando arreglos bidimensionales de longitud fija
http://www.paginasprodigy.com.mx/sanluga/arreglo4.txt

5. Accesando elementos en un arreglo bidimensional de longitud fija
http://www.paginasprodigy.com.mx/sanluga/arreglo5.txt

6. Creando arreglos bidimensionales "dentados"

http://www.paginasprodigy.com.mx/sanluga/arreglo6.txt

7. Argumentos variables ...

http://www.paginasprodigy.com.mx/sanluga/arreglo7.txt

12. Apuntadores

Te vas a dar cuenta que durante el taller estaremos utilizando distintas formas de referenciar variables de manera indirecta. Considero que dominar los apuntadores es uno de los pasos más dificiles de la programación en C/C++ pero que nos brindan poder y control sobre el código que escribimos.

Así pues, este tema puedes verlo como opcional pero que a final de cuentas te permitirá comprender algunos de los códigos más complejos. A continuación les comparto un artículo que escribí hace ya algunos años y que aunque no es managed sus conceptos continuan vigentes y que seguramente te servirá de base para comenzar a comprender el comportamiento de los apuntadores y su relación intríseca con los arreglos.


http://www.paginasprodigy.com.mx/sanluga/pointers.pdf



Los ejercicios presentados en el artículo pueden ser ejecutados dentro de VC++ 2008 Express como nuevo proyecto general y seleccionando un Empty Project. Ojo, lo vuelvo a repetir, este código no .NET sino más bien lenguaje C general:

El siguiente código, lo compile con este método, obtengo algunos warnings pero se ejecuta bien, intentalo.

http://www.paginasprodigy.com.mx/sanluga/apunta.txt

11. Funciones

Inicialmente C se basa en el paradigma estructurado, de ahi que exista un bloque de código principal y que de este se puedan invocar más código en forma de expresiones sencillas o funciones.

Hasta ahora en todos los ejemplos que se han desarrollado, todo el código va dentro del bloque main(), sin embargo para programas más complejos generalmente se divide el codigo en bloques que permiten darle una estructura lógica a nuestro programa.

Las funciones son la unidad básica de construcción en la programación estructurada y debemos revisar algunos conceptos importantes:


1. Paso de argumentos por valor y por referencia
http://www.paginasprodigy.com.mx/sanluga/funcion1.txt

2. Funciones recursivas
http://www.paginasprodigy.com.mx/sanluga/funcion2.txt

10. Estructuras de Control

Existen muchos libros en donde se pueden encontrar la estructura, sintaxis y una gran variedad de codigos para comprender mejor las estructuras de control en VC++, con el conocimiento que han adquirido hasta ahora ya deberían ser capaces de traducir cualquiera de los ejemplos que se muestran en los links y poder probarlos en MS VStudio 2008 VC++, intentalo:

Explicación del if
http://www.cprogramming.com/tutorial/lesson2.html

Explicación del switch
http://www.cprogramming.com/tutorial/lesson5.html

Explicación del for y while
http://www.cprogramming.com/tutorial/lesson3.html

Algo sobre el bloque try...catch
http://support.microsoft.com/kb/815662/es

9. Declaración de variables

La declaración de variables en Visual Studio C++ sigue las mismas reglas que C++, sin embargo el .NET Framework Class Library (FCL) System incorpora clases numéricas que nos permiten tener mayor control sobre los tipos de datos y sus conversiones.

El .NET Common Language Infraestructure (CLI) hace posible escribir codigo en diferentes lenguajes. El termino CLI-Compliant significa que el código cumple con los requerimientos .NET por lo que permite su interoperatividad. Para mayor información sugiero leer la siguiente liga:

http://decsai.ugr.es/~cb/CSharp/languaje/data.xml

A continuación pongo algunos ejemplos que involucran los tipos de datos que podemos encontrar en System.dll así como alguna de la funcionalidad más interesante. Recomiendo que examinen el código pero que revisen las los links que se recomiendan para obtener mayor profundidad en temas muy particulares y que son de gran utilidad a la hora de comprender el funcionamiento de VC++.

TIP: Cuando no recuerdes a ciencia cierta que tipo de datos requieras puedes comenzar con el namespace System seguido del operador de resolución de ámbito :: e inmediatamente el mecanismo IntelliSense incorporado a VC++ te mostrará el contenido con lo cual puedes navegar para buscar el tipo que no recuerdas.


Ejemplo 1. Declaración de un Int32:
http://www.paginasprodigy.com.mx/sanluga/tipos1.txt

Ejemplo 2. Declaración de una referencia tipo managed heap (^) .
http://www.paginasprodigy.com.mx/sanluga/tipos2.txt

Ejemplo 3. Entrada de datos desde consola
http://www.paginasprodigy.com.mx/sanluga/tipos3.txt

Ejemplo 4. Datos Booleanos (muestra el boxing implicito)
http://www.paginasprodigy.com.mx/sanluga/tipos4.txt

Ejemplo 5. Datos Byte
http://www.paginasprodigy.com.mx/sanluga/tipos5.txt

Ejemplo 6. Datos Char
http://www.paginasprodigy.com.mx/sanluga/tipos6.txt

Ejemplo 7. Datos Enteros
http://www.paginasprodigy.com.mx/sanluga/tipos7.txt

Ejemplo 8. Datos en Punto Flotante
http://www.paginasprodigy.com.mx/sanluga/tipos8.txt

Ejemplo 9. Datos decimales
http://www.paginasprodigy.com.mx/sanluga/tipos9.txt

Ejemplo 10. Datos Fecha y Hora