[C con Clase] Capitulo 12c

[Steven Davidson]

Hola David,

El pasado 2007-02-05 20:04:17, David escribió:

D> Steven, oye muchas gracias por todo, la verdad es que me has ayudado bastante, espero que no haber sido ninguna molestia . Tienes razón, he mal interpretado el siguiente texto: "Declaramos un puntero del mismo tipo que los elementos del array, y que 
D>     apunta al primer elemento del array.", y otros textos más que he leido sobre los punteros, hacen equivalencias entre punteros y arrays y me he confundido.

Me alegro de haber sido de ayuda.

D> Pero me surgen más dudas, por ejemplo, sabemos que la definición siguiente:
D>     char* p;  
D> Significa que "p" apunta a un elemento tipo char pero "p" no es una variable tipo char, o sea, que "p" contiene la dirección de memoria de un elmento que sea char. La pregunta es la siguiente "p" ocupa el tamaño en memoria igual al elemento al que apunta, o "p" por ser un puntero tiene su propia definición de tamaño por el compilador, para ser más claro, el tamaño en bytes de un puntero cualquiera siempre es igual al elemento al que apunta o el compilador define un tamaño genérico en bytes para los punteros según la arquitectura del ordenador o según el propio compilador o tienen que ver los dos.

Con una variable de tipo puntero, realmente podríamos decir que existen dos tipos: uno principal (el puntero) y otro secundario (elemento siendo apuntado). Por lo tanto, la variable siempre ocupará el mismo espacio en memoria porque es un puntero: una dirección de memoria, y las direcciones de memoria nunca cambian de tamaño, al menos que cambiemos de plataforma.

Necesitamos indicar el tipo secundario para poder manipular correctamente el dato siendo apuntado al igual que el puntero, cuando se apunte a un elemento contiguo. Por ejemplo,

int *p;
...
p += 10;

Esto implica que 'p' apuntará al undécimo entero posterior. Internamente, el compilador realizará este cálculo:

p <- p + 10*sizeof(int)

Como puedes ver, el compilador necesita conocer el tipo del dato apuntado.

D> Mi arquitectura es de 32bit por lo tanto para mi tiene lógica que el puntero, apunte al valor que apunte, siempre tenga el mismo tamaño en mi ordenador, o sea 4bytes, Por ejemplo en una arquitectura de 64bit el puntero tendría un tamaño de 8bytes apunte a char o apunte a int, etc. Pero puedo estar totalmente equivocado, aqui no estoy seguro.

No. No estás equivocado; así es como dices.

D> Otra cosa Steven tu escribiste lo siguiente: 
D> "Las posiciones o direcciones de memoria simepre existen. Lo que tenemos
D> que andar con cuidado es a la hora de usar las direcciones de memoria.
D> No todas las direcciones son válidas para nuestro uso. Dicho esto,
D> puedo hacer lo siguiente:
D> char lista[10];
D> cout << lista[12345];  // Peligro"
D> Se que para el compilador es válido, sin embargo, en este caso, el término siguiente:
D> cout << &Mes2[11][10]-Mes2[0] << endl;
D> Está bien escrito? O debería corregirlo así cout << &Mes2[11][9]-Mes2[0] << endl; porque diciembre tiene 9 caracteres más el  \0.
D> Es que al fin y alcabo no da problemas, lo que dices tú, "El sistema operativo es quien dicta si esta operación es válida o no.", por lo tanto si el sistema operativo lo admite se puede dejar o lo que conviene realmente es manejar el tamaño exacto de la cadena de caracteres.

Bueno, esto depende de lo que quieres hacer. Como expliqué en mi mensaje anterior, 'Mes2' es un array de puntero y por tanto no podemos asegurar que los arrays existan contiguamente. Lo único que podemos afirmar es que los punteros existen contiguamente. Reiterando esto, el cálculo que haces no tiene mucho sentido. Si por alguna casualidad, las cadenas apuntadas están en memoria congtigua, entonces puedes calcular la cantidad total de las cadenas. Sin embargo, no podemos asegurar que esto sea así.

Digamos que las cadenas sí existen contiguamente en memoria, entonces el cálculo sería:

&Mes2[11][10] - Mes2[0]


Espero que vayamos aclarando las dudas de este tema.

Steven