[C Language Elementary] Lo llevará a dominar fácilmente los conceptos básicos de los punteros (1): la definición, el tipo y el tamaño de los punteros

Página de inicio personal de Junxi_

Sé diligente y anima los años a no esperar a nadie.

Desarrollo de juegos C/C++

---

Hola, soy Junxi_, estoy un poco perezoso cuando recién llegué a casa y voy a reanudar la actualización hoy y comenzar a actualizar una nueva serie de preguntas de cepillado. Sigamos actualizando el contenido del lenguaje C de nivel de entrada básico 0. Hoy les traeré consejos. Pero como es un nivel elemental, pondremos un poco de uso avanzado en el capítulo avanzado, y hoy solo hablaremos sobre los conceptos básicos.

• Sin más preámbulos, ¡comencemos directamente! !
  

1. ¿Qué es un puntero?

• Para los principiantes, lo más confuso es el significado de los punteros, lo que conduce a aplicaciones incorrectas, así que hablemos de lo que son los punteros hoy.

Dos puntos clave para entender los punteros:
1. Un puntero es el número de la unidad más pequeña en la memoria, es decir, la dirección
2. El puntero al que solemos referirnos en el lenguaje hablado generalmente se refiere a una variable de puntero, que es una variable utilizada para almacenar direcciones de memoria

• Resumen: un puntero es una dirección, y un puntero en el lenguaje hablado generalmente se refiere a una variable de puntero.

Variables de memoria y puntero

• Memoria
  
• variable puntero

Podemos usar & (operador de dirección) para sacar la dirección de inicio de la memoria de la variable y almacenar la dirección en una variable, que es nuestra variable de puntero

#include <stdio.h>
int main()
{
    
    
    int a = 10;//在内存中开辟一块空间
    int* p = &a;//这里我们对变量a，取出它的地址，可以使用&操作符。
    //a变量占用4个字节的空间，这里是将a的4个字节的第一个字节的地址存放在p变量中，p就是一个之指针变量。
    return 0;
}

• Resumir:
• Una variable de puntero es una variable utilizada para almacenar una dirección. (El valor almacenado en el puntero se trata como una dirección).
• La pregunta aquí es:
• ¿Qué tan grande es una unidad pequeña? (1 byte)
• ¿Y cómo dirigirse?
• Después de un cuidadoso cálculo y pesaje, encontramos que es más apropiado asignar un byte a una dirección correspondiente.
• Para una máquina de 32 bits, suponiendo que hay 32 líneas de dirección, luego suponiendo que cada línea de dirección genera un nivel alto (alto voltaje) y un nivel bajo (bajo voltaje) durante el direccionamiento (1 o 0); entonces la dirección generada por las 32 líneas de dirección será
  :
  
• 64位机器同理，有64位地址线，这里仅以32位机器为例。
• 二进制，由于有32根地址线，所以一共有2的32次方个字节的空间，也就产生了这么多的编号。
  
• Sabemos (2^32Byte = 2^32/1024KB =2^32/1024/1024MB = 2^32/1024/1024/1024GB = 4GB)
• En este punto podemos abordar el espacio de 4GB.
• Aquí entendemos:
• En una máquina de 32 bits, la dirección es una secuencia binaria compuesta de 32 0 o 1, y la dirección debe almacenarse en 4 bytes, por lo que el tamaño de una variable de puntero debe ser de 4 bytes.
• Entonces, si en una máquina de 64 bits, si hay 64 líneas de dirección, el tamaño de una variable de puntero es de 8 bytes para almacenar una dirección.

Resumen:
las variables de puntero se utilizan para almacenar direcciones, y las direcciones identifican de forma única una unidad de memoria.
El tamaño del puntero es de 4 bytes en plataformas de 32 bits y de 8 bytes en plataformas de 64 bits

---

2. Punteros y tipos de punteros

• Al igual que las variables, los punteros también vienen en diferentes tipos.

int *p;     //定义一个指针变量P，指向整形变量 
char *p;		// 定义一个指针变量p，指向字符型变量 
float * p; 		// 定义一个指针变量p，指向单精度浮点型变量 
double *p1, *p2;		//定义两个指针变量p1和p2，指向双精度实型变量 

• 这里可以看到，指针的定义方式是： type + * 。(type指类型名)

puntero ± entero

• Echemos un vistazo al código:

#include <stdio.h>
//演示实例
int main()
{
    
    
    int n = 10;
    char* pc = (char*)&n;
    int* pi = &n;
    printf("%p\n", &n);
    printf("%p\n", pc);
    printf("%p\n", pc + 1);
    printf("%p\n", pi);
    printf("%p\n", pi + 1);
    return 0;
}

• El %p aquí significa imprimir la dirección.
• 1. Podemos ver en los resultados de la impresión que las direcciones de &n y pc son las mismas, es decir, ambas apuntan al mismo lugar. (Aquí, dado que n es un tipo int, debemos convertirlo en un tipo char antes de usarlo)
• 2. De 2 y 3, podemos ver que agregar 1 al puntero significa agregar 1 a la dirección, es decir, la dirección apunta al siguiente bit.
  - 3. De 3, 4 y 5, podemos ver que las direcciones de diferentes tipos de punteros más 1 son diferentes, que están relacionadas con el tipo de variable de puntero.
• Resumen: el tipo de puntero determina la distancia que el puntero da un paso hacia adelante o hacia atrás (distancia)
• Sin embargo, aquí necesitamos saber que bajo el mismo sistema operativo, ¡el tamaño de la variable del puntero es el mismo!

el tamaño de la variable del puntero

• Anteriormente hablamos sobre la forma en que los punteros se almacenan en la memoria y el tamaño del espacio de almacenamiento.Cuanto espacio haya, naturalmente habrá tantas direcciones, es decir, tantos punteros.
• Pruébalo con código:

#include <stdio.h>
//指针变量的大小取决于地址的大小
//32位平台下地址是32个bit位（即4个字节）
//64位平台下地址是64个bit位（即8个字节）
int main()
{
    
    
  printf("%d\n", sizeof(char *));
  printf("%d\n", sizeof(short *));
  printf("%d\n", sizeof(int *));
  printf("%d\n", sizeof(double *));
  return 0;
}

• Mi computadora es una plataforma de 64 bits, por lo que el tamaño del puntero es de 8 bytes

Resumen:
La dirección bajo la plataforma de 32 bits es de 32 bits (es decir, 4 bytes)
La dirección bajo la plataforma de 64 bits es de 64 bits (es decir, 8 bytes)

puntero desreferenciado

#include <stdio.h>
int main()
{
    
    
    int n = 0x11223344;
    
    int* pi = &n;
    *pi = 0;
   char* pc = (char*)&n;
   *pc = 0;
    return 0;
}

• Lo anterior es el almacenamiento de pi en la memoria, cuando cambiamos el valor en pi a 0
  
• Los datos almacenados en los 4 bytes se cambian todos a 0
  
• Lo anterior es la dirección de la pc en la memoria.Podemos ver que cuando los datos en la dirección también se cambian a 0, solo se cambia la dirección de un byte.
• Resumir:
• El tipo del puntero determina cuánta autoridad (cuántos bytes se pueden manipular) al desreferenciar el puntero.
• Por ejemplo: la desreferenciación del puntero de char * solo puede acceder a un byte, y la desreferenciación del puntero de int * puede acceder a cuatro bytes.

Resumir

• El contenido de hoy está aquí por el momento. Hoy, primero hablaremos sobre la definición, el tipo, el tamaño y las diferencias de los diferentes tipos de punteros. El resto lo explicaremos por lotes.

• Bueno, si tiene alguna pregunta, por favor pregúnteme en el área de comentarios o mensaje privado, ¡hasta la próxima!

No es fácil crear un nuevo blogger. Si cree que el contenido del artículo es útil para usted, puede hacer clic en este nuevo blogger antes de irse. ¡Tu apoyo es mi motivación para actualizar! ! !

**(¡Ke Li te pide que apoyes al bloguero tres veces seguidas! Haz clic en el comentario a continuación para darle me gusta y recolectar para ayudar a Ke Li)**