Hola y bienvenido de nuevo.
En esta conferencia, quiero hablar sobre cómo acceder al valor
al que apunta un
puntero. Recuerde que los punteros almacenan direcciones de memoria.
Esa dirección de memoria en realidad contiene un valor de algún lugar.
Y así, los punteros apuntan a esa dirección de memoria. Quiero obtener el valor de
lo que apunta.
Debido a que solo imprimiría el valor de un puntero que sería una dirección, pero quiero obtener la dirección, quiero
obtener el valor de la dirección.
Por lo tanto, puede acceder al valor de una dirección a la que apunta
un puntero mediante el operador de indirección. El operador de indirección es el asterisco.
Entonces aprendimos cómo usar el asterisco para declarar un
puntero, también usaremos el asterisco para encontrar el valor al que apunta un puntero.
Por lo tanto, también se lo conoce como operador de
desreferencia porque lo usa para desreferenciar un puntero.
Entonces, por ejemplo, si tiene un número que es igual a 15, declara
un puntero de tipo int, apunta a un int y le asigna la dirección del número usando el ampersand.
Ahora, ¿cómo se obtiene el valor de a qué apunta el puntero?
Puede quitar la referencia.
Básicamente, puede saber cuál es el valor al que apunta el
puntero, el valor es 15 porque apunta a la dirección del número que es 15.
Entonces, la variable de puntero contiene la dirección del número de variable.
Puede usar esto en una expresión para calcular un nuevo valor para el resultado.
Entonces, digamos que queremos que el resultado sea igual al valor
al que apunta el puntero más cinco. Usaría el asterisco
antes del nombre del puntero.
Entonces, lo que esto haría es básicamente decir a qué apunta
la variable de puntero, está apuntando a 15 y suma cinco.
Es la dirección a
la que apunta el puntero cuál es el valor de esa dirección.
Entonces, el asterisco del operador de
indirección que debe notar es también el símbolo que se usa para la multiplicación, y también
se usa cuando declara tipos de puntero. Entonces esto puede resultar muy confuso.
¿Cómo sabe necesariamente qué está pasando o cómo funciona el compilador?
Bueno, se trata de contexto. Depende de cuándo use ese asterisco y dónde lo use.
Si usa el asterisco cuando declara un puntero justo después
del tipo
de puntero, entonces obviamente está usando una declaración.
Si usa el asterisco entre dos números,
entonces se usa para la multiplicación. Y si se usa justo
antes del nombre del puntero en el lado derecho, por ejemplo, o en el lado
izquierdo, será para asignar un valor o acceder a un valor.
Entonces, se trata de contexto cuando usa este operador
de indirección.
Y así es como funciona.
Así es como lo va a interpretar el compilador.
Siempre que lo vea en, este ejemplo, puntero de
estrella y no tenga un tipo de datos antes o no tenga
dos números en cada lado, entonces sabrá que es un puntero de indirección, desreferenciación.
Así que veamos un ejemplo. Aquí hay otro
ejemplo en el que vamos a crear un
número entero igual a 10. También vamos a crear un número entero de tipo llamado x otra variable.
Estamos inicializando el recuento en 10, x se inicializa en nada.
Luego creamos un puntero int. Sabemos que es un puntero
int porque tenemos el asterisco después del tipo
de datos y luego lo llamamos puntero int.
Ahora vamos a asignar a ese puntero int la dirección de count.
Porque recuerde, los punteros solo contienen direcciones como sus valores,
pero también apuntan a algo.
Entonces podemos asignar la variable x a lo que sea que apunte el puntero int, cuál
es el valor de la dirección que está contenida en el puntero.
Entonces x realmente mostrará 10.
10. Entonces, si seguimos adelante y mostramos que diciendo
count percent d ird x percent ird, count es igual a 10, x va a ser igual a 10.
Así es como se puede eliminar la referencia de un puntero y obtener el valor de eso. Apunta a si desea mostrar
los valores del puntero porque recuerde que un puntero tiene
un valor en la memoria, es
solo una dirección. Entonces, ¿qué sucede si
desea mostrar el valor de los punteros, que está
representado por un número entero hexadecimal y una dirección?
Bueno, puede usar el especificador de formato porcentaje p. Hablamos de esto antes.
Esto generará un valor de puntero como una dirección de memoria en forma hexadecimal.
Entonces, si hiciéramos algo como esto
donde declaramos nuestro número,
declaramos nuestro puntero, lo inicializamos en nulo porque esa es una buena práctica, queremos hacer siempre
que cuando no esté asignando algo en una declaración al puntero, haga asegúrese de
inicializarlo en nulo.
Luego asignamos nuestra variable numérica 10.
Y luego asignamos nuestro puntero a la dirección del número.
Entonces, el valor del número p en realidad será una dirección.
Una dirección. Entonces, si intentáramos imprimirlo, usaríamos el porcentaje py ese sería el valor de la dirección.
Si quisiéramos imprimir a qué apunta, tendríamos que eliminar
la referencia utilizando el operador de indirección.
Pero cuando imprime la dirección, lo que hace es imprimirla en
hexadecimal y los punteros ocupan 8 bytes en la
memoria, y las direcciones tienen
16 dígitos hexadecimales. Entonces, ¿cómo funciona eso?
Bueno, depende de si su máquina admite direcciones de 64 bits o de 32 bits.
Si su máquina tiene un sistema operativo de
64 bits, verá 16 dígitos hexadecimales.
Si su máquina o su sistema operativo solo tiene
direccionamiento de 32 bits, verá el hexadecimal representado como 8 dígitos hexadecimales.
Ahora, ¿qué pasa si desea mostrar una dirección?
Puede decir cuál es la diferencia porque el puntero tiene un valor.
Pero también puede mostrar la dirección con la dirección del operador.
Entonces, en este ejemplo, queremos mostrar la dirección del número.
El número no es un puntero. El número es solo un número entero.
Si queremos obtener la dirección de eso, usamos el ampersand.
Si queremos mostrar la dirección de eso, simplemente use el porcentaje p nuevamente.
Solo aplica el ampersand.
Entonces, si proporcionamos el ampersand con la variable de puntero, en
realidad mostraríamos la dirección de ese puntero,
no el valor del punto. Recuerde que la dirección del puntero es una dirección en la memoria.
El valor del puntero es una dirección a la que apunta.
Y el valor al que apunta está en otro lugar de la memoria.
Así que recuerde esa ilustración en
la que mostramos cómo funcionan los punteros.
Un puntero, cuando lo declaras, crea memoria para ese puntero,
8 bytes.
El valor de ese puntero es una dirección.
Y luego, lo que sea que
apunte ese puntero es un valor, generalmente del tipo que proporcionó.
Pero recuerde que en realidad hay tres partes.
Si desea imprimir la dirección de los números p, nuevamente debe usar el signo comercial.
Esa sería la dirección del puntero real.
Y tendrías que usar la estrella del vacío para evitar una advertencia.
Así que recuerde, un puntero en sí mismo tiene una dirección, al igual que
cualquier otra variable, se asigna cuando la declara.
Utiliza el porcentaje p como un especificador de conversión para mostrar direcciones.
Utiliza el signo comercial y la dirección del operador para hacer referencia a la
dirección que ocupa la variable de número p.
Esa es la dirección del puntero. Por otra parte, el puntero tiene
el valor de una dirección.
El lanzamiento de un vacío es para evitar una advertencia del compilador,
específicamente la especificación de porcentaje p espera que el valor sea algún tipo de tipo de puntero.
Pero el tipo de número comercial es un puntero a un puntero del mismo.
Y entonces tienes que lanzarlo.
Muestra el número de bytes que utiliza un puntero.
Otra forma de obtener información sobre un puntero.
Aquí puede utilizar el operador sizeof. Hemos aprendido sobre el tamaño del
operador para mostrar bytes de diferentes tipos de datos. Puede hacer lo mismo con un puntero.
En una máquina que estoy ejecutando, esto ocupará 8 bytes.
Y la dirección de la máquina tiene 64 bits porque
es un sistema operativo de 64 bits.
Y es posible que reciba una advertencia del compilador cuando use size de esta manera, sizet
es un tipo de entero definido por la implementación.
Para evitar la advertencia, puede convertir el argumento a un tipo int como este.
Entonces, lo que haría es decir p tamaño del número, porcentaje d bytes.
Y diría int, conviértalo en un tamaño de pulgada del número p.
Eso le dará el tamaño del puntero en la memoria, el tamaño del puntero de esa dirección,
que, nuevamente, es de ocho bytes en la mayoría de los sistemas.
Porque eso solo contiene una dirección.
Otro ejemplo aquí. Esto mostrará una serie de cosas.
Y ejecutaremos este ejemplo para mostrar el resultado.
Pero justo antes de ejecutarlo, quiero describir un poco lo que está sucediendo aquí. Tenemos un número declarado.
Tenemos un puntero que inicializa el nulo.
Establecemos el valor del número en 10.
Y luego lo que queremos hacer es imprimir
la dirección del número entero, y queremos imprimir el valor del número, muy simple,
usando la dirección del operador y luego solo la variable.
Cuando hacemos la dirección del operador, hacemos el porcentaje p.
Luego vamos a asignar la dirección del número a nuestro puntero.
A continuación, imprimiremos información sobre el puntero.
Queremos generar la dirección del puntero en sí.
Solo podemos usar el porcentaje p, el número comercial de estrella vacía.
Queremos ver cuántos bytes tiene ese puntero en la memoria. Podemos decir sizeof.
Queremos ver el valor real del puntero, que
es una dirección. Podemos simplemente decir el número p
sin ninguna información adicional y luego usamos el porcentaje p.
Si queremos ver el valor al que
apunta el puntero, el valor en la dirección, entonces
marcamos el número p, usamos el operador de indirección.
Y sabemos que el número p apunta a una en, por lo que podemos decir el porcentaje d.
Así que echemos un vistazo a este ejemplo en bloques de código para ver cómo se muestra realmente.
Lo que veremos son algunos números
hexadecimales para direcciones cada vez que mostramos direcciones y veremos valores en otros casos.
Entonces esto debería parecer familiar. Este es solo un programa
que le muestra cómo acceder a diferentes partes de un puntero.
De nuevo, tenemos un tipo de datos numérico regular int, y
tenemos nuestro puntero. Lo inicializamos a nulo.
Primero mostraremos nuestro número, que es 10. Entonces esto mostrará la dirección del número,
y luego mostrará el valor del número en las líneas 10 y 11.
Luego asignaremos nuestro puntero, la dirección del número.
Si queremos ver la dirección real de nuestro puntero, usamos el ampersand, la dirección
del operador, y lo convertimos en estrella vacía.
Usamos el porcentaje p.
Si queremos ver cuántos bytes tiene el puntero en la memoria, hacemos el porcentaje d sizeof.
Si queremos ver la dirección el valor de maní el puntero, hacemos porcentaje p
y simplemente decimos p número, porque p número es una dirección.
Si queremos ver a qué apunta el puntero con el valor de
la dirección que está en el valor del puntero, simplemente decimos
asterisco p número, lo desreferenciamos, el operador de indirección.
Así que ejecutemos esto.
Cuando ejecuto esto, verá las dos primeras cosas que se
imprimen, la dirección de los números que
está en la línea seis, y ese es un número hexadecimal, 0060ff0c.
Y esto en realidad está ejecutando un programa de 32 bits, por lo que verá que solo tiene
8 bits.
la variable numérica que es 10.
Luego imprimimos la dirección del puntero real a la memoria asignada.
Es una dirección diferente al número.
Porque esta es la dirección asignada para el puntero.
El tamaño del número de puntero es de 4 bytes, y
eso significa que es un direccionamiento de 32 bits.
El valor del puntero, que es
la dirección del número, debe ser el mismo y es 0060ff0c.
Y verá que en realidad puede obtener la dirección
del número simplemente usando el nombre, el puntero con porcentaje p.
Vimos el tamaño del operador 4 bytes.
Si desea obtener el valor al que apunta el número p, que
es 10, debe eliminar la referencia utilizando el operador de indirección y verá que se imprime como 10.
Pero ves que usas el porcentaje p siempre que estás
mostrando direcciones, usa el porcentaje e cuando estás mostrando valores del puntero entero o
el número de bytes.
Entonces, esta es la sintaxis básica para acceder a los valores de puntero.
Dirección del puntero, ampersand, valor al que
apunta el punto, solo el nombre de la variable
y el valor del puntero en sí es solo el nombre de la variable, luego
el valor al que apunta el puntero para usar el operador de indirección.
Gracias. Espero que esto ayude. Estudie esto, analice esto.