Programación Orientada a Objetos

.
Programación Orientada a Objetos

La diferencia entre Programación Orientada a Objetos (POO) y Programación Estructurada (PE) es el enfoque con el que se encara y se resuelve el problema.

En PE pensamos en los datos y luego en los procesos (o funciones) necesarios para operar con esos datos, en cambio, en POO pensamos en los objetos que existen e interactúan dentro del contexto del problema que queremos resolver. Es decir, dentro del contexto del problema existen objetos de diferentes tipos (clases), autosuficientes y capaces de interactuar entre si.

Para comprender esta diferencia plantearemos el siguiente problema:

Problema
Se desea desarrollar un programa que permita ingresar un conjunto de números positivos por teclado para luego imprimirlos en orden inverso. El fin de datos se indicará ingresando un número negativo.

Análisis
La manera más simple de resolver este problema será utilizar una pila (estructura de datos) en la que apilaremos los números a medida que el usuario los ingrese y luego los desapilaremos hasta que la pila quede vacia. Como el último elemento que se apila será el primero que se desapila (LIFO) el orden de salida de los elementos del conjunto será inverso al orden en que fueron ingresados.

Comenzaremos por resolver el problema en C (programación estructurada).

El primer paso será desarrollar "la pila" para luego, en el programa principal, utilizarla para apilar y desapilar el conjunto de datos que ingrese el usuario.

Implementaremos la pila sobre un array.

pila.c

 1:
 2:#include <stdio.h>
 3:
 4:void poner(int arr[], int *size, int v)
 5:{
 6:   arr[(*size)++]=v;
 7:}
 8:
 9:int sacar(int arr[],int *size)
10:{
11:   return arr[--(*size)];
12:}
13:

Veamos la función main que en la que se piden los valores del conjunto, se los apila y luego se los desapila para mostrarlos en orden inverso.

testPila.c

   1:
   2:#include <stdio.h>
   3:
   4:int main()
   5:{
   6:   int a[10];     // array para usar la pila
   7:   int pSize=0;   // tamanio de la pila
   8:
   9:   int v;         // variable para leer x teclado
  10:
  11:   // el usuario ingresa un valor
  12:   printf("Ingrese un valor: ");
  13:   scanf("%d", &v);
  14:
  15:   while( v != 0 )
  16:   {
  17:      // apilo el valor ingresado x el usuario
  18:      poner(a, &pSize, v);
  19: 
  20:      // el usuario ingresa el proximo valor
  21:      printf("Ingrese un valor: ");
  22:      scanf("%d", &v);
  23:   }
  24:
  25:   // mientras la pila tenga elementos
  26:   while( pSize>0 )
  27:   {
  28:      // saco y muestro un elemento
  29:      printf("%d\n", sacar(a,&pSize));
  30:   }
  31:}
  32:

En la función main tenemos que definir un array de enteros (a) y un entero (pSize) ya que la pila se monta sobre esas variables. Luego pasamos estas variables a las funciones poner y sacar para apilar y desapilar los valores que ingresa el usuario.

Veamos ahora que sucede si cambiamos la implementación de la pila. En lugar de utilizar un array impementaremos la pila sobre una lista enlazada.

El nodo lo definimos así:

pila.h

   1:
   2:struct Nodo
   3:{
   4:   int info;
   5:   struct Nodo *sig;
   6:} typedef Nodo;
   7:

Ahora las funciones poner y sacar serán las siguientes:

pila.c (ahora se implementa sobre una lista enlazada)

   1:
   2:#include <stdio.h>
   3:#include "pila.h"
   4:
   5:void poner(Nodo **p, int *size, int v)
   6:{
   7:   Nodo *nuevo=(Nodo*)malloc(sizeof(Nodo*));
   8:   nuevo->info=v;
   9:   nuevo->sig=*p;
  10:   (*size)++;
  11:   *p=nuevo;
  12:}
  13:
  14:int sacar(Nodo **p,int *size)
  15:{
  16:   int ret=(*p)->info;
  17:   Nodo *aux=*p;
  18:   *p=(*p)->sig;
  19:   free(aux);
  20:   (*size)--;
  21:   return ret;
  22:}
  23:

La nueva implementación de la pila influye sobre la función main ya que ahora, en lugar de definir un array para pasarle a las funciones poner y sacar tenemos que definir un puntero a Nodo.

testPila.c (utiliza la nueva implementación de la pila)

   1:
   2:#include <stdio.h>
   3:#include "pila.h"
   4:
   5:int main()
   6:{
   7:   Nodo *p;       // puntero al 1er. nodo de la pila
   8:   int pSize=0;   // tamanio de la pila
   9:   int v;
  10:
  11:   // ingreso un valor
  12:   printf("Ingrese un Valor: ");
  13:   scanf("%d",&v);
  14:
  15:   while( v>0 )
  16:   {
  17:      // apilo el valor ingresado x el usuario
  18:      poner(&p,&pSize,v);
  19:
  20:      // el usuario ingresa el siguiente valor
  21:      printf("Ingrese un Valor: ");
  22:      scanf("%d",&v);
  23:   }
  24:
  25:   // mientras la pila tenga elementos 
  26:   while( pSize>0 )
  27:   {
  28:      // saco y muestro un elemento
  29:      printf("%d\n", sacar(&p,&pSize));
  30:   }
  31:
  32:   return 0;
  33:}
  34:

En el programa principal además de trabajar con el conjunto de números tenemos que mantener el puntero a la pila (p) y una variable entera (pSize) que utilizarán las funciones poner y sacar a medida que se agregan o se sacan elementos.

Decimos entonces que en Programación Estructurada (PE) el programador no puede abstraerse de los temas de implementación.

Es decir, quien desarrolle el programa principal necesita conocer la implementación de la pila ya que la responsabilidad de mantener los datos de la pila es del mismo programa principal.

.