[C con Clase] Hola amigos de C++......duda con funci

[Steven Davidson]

Hola Miguel Ángel,

2011/11/19 Miguel Angel Torres Fernandez-piñar <miguelangeltorresfp en gmail.com>:
> Gracias Steven....
>
> A ver....la respuesta de que un puntero es un puntero......etc....
>
> Uf....me cuesta entendero........
>
> Si hacemos ........ int a;
>                            int *p = &a;
> p es un puntero a entero, nunca podríamos usarlo para apuntar a un char, no
> ???.......por tanto es diferente de un puntero a char, no ???........(
> perdona que insista pero es que no termino de entenderlo ).
>

Sí. Un puntero a 'char' es diferente a un puntero a 'int', en cuanto
al tipo de dato concierne. Sin embargo, existe una relación entre
estos dos tipos, porque ambos son punteros. Piensa que un puntero es
como un tipo de dato complejo, porque contiene dos tipos de datos:

1. El puntero en sí y por tanto la memoria que concierne al valor
guardado en tal variable que es una dirección de memoria. Por lo
tanto, cualquier puntero puede ocupar 4 bytes u 8 bytes, dependiendo
del sistema operativo.

2. El tipo de dato apuntado. Aquí es lo que realmente crea la
distinción entre un puntero y otro.

Por lo tanto, 'int *', 'char *', 'long double *', etc. ocupan 4 bytes
en memoria, porque un puntero sigue siendo un puntero; y por tanto, se
guarda una dirección de memoria. Por ejemplo,

int num = -10;
char car = 'a';

int *pNum = #
char *pCar = &car;

La gran diferencia está en el acceso a la información apuntada. Por
ejemplo, podríamos hacer esto:

pCar = (char *) pNum;

Como un puntero sigue siendo un puntero, no hay problema de memoria
para albergar una dirección de memoria, ya que una dirección de
memoria ES una dirección de memoria. Lo anterior nos sirve para
reinterpretar la información apuntada, que en lugar de servirnos para
describir un entero de tipo 'int', ahora sirve para acceder a cada
byte, porque 'char' siempre ocupa 1 byte. Podríamos mostrar esas
secuencias de bits del entero como si fueren códigos ASCII. Por
ejemplo,

cout << pCar[0] << pCar[1] << pCar[2] << pCar[3] << endl;

Aparecerá algo extraño, seguramente.

> Y en nuestro caso de clases derivadas....
>
> En.......  Persona *Carlos = new Empleado("Carlos");   // siendo Empleado
> una clase derivada de Persona.
>
> Carlos puede ser tratado tanto como puntero a clase Persona como puntero a
> clase Empleado ???
>

Sí; pero la razón es debida al polimorfismo. De lo contrario,
tendríamos que hacer un cásting explícito, al no haber una relación
entre 'Persona *' y 'Carlos *'. Como las clases sí tienen relación
entre sí, el lenguaje nos permite hacer el "cambio" de derivada a
base, sin problemas, y de hecho, de una forma correcta, según el tipo;
es decir, sin reinterpretación de la secuencia de bits.

De todas maneras, el puntero 'Carlos' sigue siendo de 4 bytes, porque
guarda una dirección de memoria; ya sea el primer byte del objeto de
la clase 'Empleado' o ya sea de la clase 'Persona'. Sin embargo, como
he dicho, no hay reinterpretación de la secuencia de bits; sino que se
reinterpreta de otra manera de mayor nivel - de una forma más lógica.


Espero haber aclarado las dudas.

Steven