[C con Clase] ayuda de concepto de C++

[Steven Davidson]

Hola José Ramón,

2011/8/29 Jose Ramon Dominguez Barba <josedb_90 en hotmail.com>:
> Buen dia
>
>
> Soy estudiante en ing electronica, y comence con las bases de programacion
> con C estandar, ahora estoy iniciando con C++, ya leí 3 libros y mas el
> manual de mi maestro junto con su explicacion, pero aun no logro entender
> las definiciones principales: clases, objetos,herencia, etc.
>
>
> No he logrado hacer una comprencion sobre las definiciones, su aplicaciones,
> en pocas palabras no logro comprender y asimilar la modalidad de c++; y el
> ejemple del automovil casi me lo aprendo de memoria.
>

Si conoces la metodología de la programación modular o estructural, la
programación orientada a objetos (POO) no debería resultarte tan
difícil de entender, ya que personalmente la considero una extensión
de la programación modular y posiblemente una formalización de su
implementación. Por ejemplo, en la programación modular, diseñaríamos
una superficie gráfica para un sistema gráfico muy básica de la
siguiente manera:

Para la representación de la información,

struct superficie_grafica
{
  int *pPixeles;
  int nAnchura;
  int nAltura;
};

Y ahora sus operaciones,

bool iniciar_sg( superficie_grafica **ppSuperficie, int nAnchura, int nAltura );
bool finalizar_sg( superficie_grafica **ppSuperficie );

int consultarAnchura_sg( superficie_grafica *pSuperficie );
int consultarAltura_sg( superficie_grafica *pSuperficie );

bool ponPixel_sg( superficie_grafica *pSuperficie, int nFila, int
nCol, int nColor );
bool consultaPixel_sg( superficie_grafica *pSuperficie, int nFila, int
nCol, int *pColor );

Para usar correctamente esta superficie gráfica, tendríamos que estar
atentos a invocar 'iniciar_sg()' antes de usar una superficie e
invocar 'finalizar_sg()' a la hora de terminar de usarla. Además,
tenemos como operaciones básicas asignar un color a un píxel en
particular al igual que consultar su color. Por ejemplo, un programa
podría ser el siguiente:

superficie_grafica *pImagen;

iniciar_sg( &pImagen, 200, 200 );  // una imagen/superficie de 200x200
de resolución

  for( int f=0; f < consultarAltura_sg( pImagen ); f++ )
    for( int c=0; c < consultarAnchura_sg( pImagen ); c++ )
      ponPixel_sg( pImagen, f, c, 0 );  // Asignamos negro - 0 (cero)
- a todos los píxeles

finalizar_sg( &pImagen );

Creo que esto es sencillo de entender, especialmente con los nombres
descriptivos de las funciones. Con la POO, queremos concretar y
formalizar este concepto de la superficie gráfica encapsulando todo lo
relevante a este concepto. Esto significa que guardamos tanto la
información que representa la superficie gráfica como sus operaciones
básicas: las funciones. Por ejemplo,

class superficie_grafica
{
private:
  int *pPixeles;
  int nAnchura;
  int nAltura;

public:
  superficie_grafica( int nAnchura, int nAltura );
  ~superficie_grafica();

  int consultarAnchura() const;
  int consultarAltura() const;

  bool ponPixel( int nFila, int nCol, int nColor ) const;
  bool consultaPixel( int nFila, int nCol, int *pColor );
};

El uso es ahora,

superficie_grafica imagen( 200, 200 );

for( int f=0; f < imagen.consultarAltura(); f++ )
  for( int c=0; c < imagen.consultarAnchura(); c++ )
    imagen.ponPixel( f, c, 0 );

La verdad es que deberíamos formalizar un poco más el concepto de un
color para tener una mejor representación en lugar de usar 'int'
directa y explícitamente.

Sin saber muy bien los problemas, dudas, e inquietudes que estás
teniendo, no puedo dar una explicación detallada de la POO. La idea
básica de la POO es programar a un nivel más alto; o sea, más cercano
a cómo pensamos y percibimos los humanos cualesquier conceptos. Por
ejemplo, si alguien le pregunta qué es una tostadora y cómo se usa, no
te vas a poner a explicarle la física cuántica ni todo lo relacionado
con la electricidad. No es necesario entrar a tan "bajo nivel" para
explicar el concepto de una tostadora, aunque ésta tenga que ver con
la electricidad, los electrones, y la energía en este universo.
Nosotros, como humanos, nos arreglamos muy bien con conceptos
generales y poco detalle. Si es necesario, entonces entramos en
detalles, pero si no, sólo nos interesa saber lo justo para poder usar
ese "algo" y tener una ligera idea de lo que puede suceder al
interactuar ese "algo" con otro "algo". En el caso de la tostadora,
nos interesaría saber qué sucede al colocar rebanadas de pan en ella;
o sea, cómo interectúan estos dos conceptos. También necesitaríamos
saber cómo interactúan la tostadora y el enchufe a la red eléctrica.

Esta forma de pensar nos ayuda a la hora de afrontar problemas
complejos y centrarnos en el uso de estos conceptos individual y
conjuntamente para dar soluciones complejas. La idea principal es que
la POO se asemeja a nuestra forma de pensar como humanos, sin tener
que pensar como máquinas. Obviamente, quien esté diseñando cada clase
tendrá que pensar en los detalles, pero esa parte queda dentro de tal
clase. Al haber una separación de los detalles: la implementación y la
comunicación con el resto del programa, podemos modificar esos
detalles si hace falta, sin modificar esta comunicación y por tanto su
uso.


Espero haber aclarado algo de este tema.

Steven