Definición y uso de variables puntero en lenguaje C (esencia)
La "dirección" de "datos" en la memoria también se convierte en un "puntero". Si una variable almacena un "puntero" de datos, la llamamos "variable de puntero".
En el lenguaje C, se permite usar una variable para almacenar punteros, y llamamos a esta variable variable de puntero.
"El valor de la variable de puntero" es la "dirección" de una determinada pieza de datos, dicha pieza de datos puede ser "matriz, cadena, función, y la página puede ser otra variable ordinaria o variable de puntero"
Ahora asumimos que existe una "variable tipo char c" que almacena un carácter 'K' (el código ASCII es 75 en decimal) y ocupa la memoria con dirección OX11A (la dirección suele expresarse en hexadecimal)
Además, existe una "variable puntero p" cuyo valor es OX11A, que es exactamente igual a "la dirección de la variable c". En este caso, se dice que "p apunta a c" o "p es un puntero a variable puntero c".
1. Definir variable de puntero
Es muy similar a la definición de variables ordinarias, pero agrega un asterisco * antes del "nombre de la variable"
El formato es:
tipo de datos *kangkang;
o:
tipo de datos *kangkang = valor;
variable puntero: *
El tipo de datos al que apunta la variable de puntero: tipo de datos
//Por ejemplo:
entero *p1;
p1 es una "variable de puntero" que apunta a datos de tipo int. En cuanto a qué dato apunta p1, debe determinarse por el valor que se le asigna.
Por ejemplo:
int a = 100;
int *p_a= &a;
Inicialice la variable puntero p_a mientras la define , y asígnele la dirección de la variable a , luego p_a apunta a a .
Cabe señalar que p_a necesita una dirección. ! !
Por lo tanto, a debe estar precedido por "tomar el carácter de dirección &", de lo contrario, será incorrecto. ! !
Al igual que las variables ordinarias, los punteros también se pueden escribir varias veces, siempre que lo desee, puede cambiar el valor de la variable del puntero en cualquier momento.
detalles de la siguiente manera
//Definir variables comunes
flotante a = 99.5,b = 10.6;
carácter c = 'q', d = '#'
//Definir variable de puntero
flotante *p1 = &a;
carácter *p2 = &c;
//Modificar el valor de la variable puntero
p1 = &b;
p2 = &d;
//¡Aviso! !
1. * es un símbolo especial que indica que una variable es un puntero, y * debe incluirse al definir p1 y p2.
2. Al "asignar" valores a p1 y p2, porque el compilador ya sabe que es una variable de puntero, por lo que no hay necesidad de hacer nada más, y la variable de puntero se puede usar como una variable ordinaria.
3. Es decir, * debe usarse al definir una variable de puntero y * no puede usarse al asignar un valor a una variable de puntero.
¡Las variables de puntero también se pueden definir de forma continua!
Por ejemplo:
int *a,*b,*c; //Los tipos de puntero abc son todos int*
Tenga en cuenta que cada variable debe ir precedida de un *. Si se escribe de la siguiente forma, entonces solo a es una variable apuntadora y bc es una variable ordinaria de tipo int.
int *a,b,c; //solo a es int*
2. Obtención de datos a través de variables puntero
La variable de puntero almacena la "dirección de los datos", y los "datos en la dirección" se pueden obtener a través de la variable de puntero.
El formato es:
*entrepierna;
* se denomina " operador de puntero " y se utiliza para obtener datos en una dirección .
// Dar un ejemplo de un programa
#include<stdio.h>
int main()
{
int a = 15;
int *p = &a;
printf("%d,%d\n",a,*p);
return 0;
}resultado:
15,15
Suponiendo que la dirección de a es 0X1000, después de que p apunte a a, el valor de p también se convertirá en 0X1000, *p significa obtener los datos en la dirección 0X1000, es decir, el valor de la variable a. A partir de los resultados de ejecución, *p y a son equivalentes.
//El puntero no solo puede obtener los datos en la memoria, sino también modificar los datos en la memoria,
Por ejemplo:
#include<stdio.h>
int main()
{
int a = 15,b = 99,c = 222;
int *p = &a; //定义指针变量
*p = b; //通过指针变量修改内存上的数据
c = *p; //通过指针变量获取内存上的数据
printf("%d,%d,%d,%d\n",a,b,c,*p);
return 0;
}El resultado es:
99,99,99,99
*p representa los datos en a, que es equivalente a a, y se le puede asignar otro dato, o se puede asignar a otra variable.
* Tiene diferentes funciones en diferentes escenarios:
1. *En la definición de la variable puntero, se puede indicar que esta es una variable puntero (para que todos puedan distinguirla de las variables ordinarias)
2. Al usar "variable de puntero", agregue * delante para indicar "obtener los datos a los que apunta el puntero" o, en otras palabras, "los datos mismos a los que apunta el puntero".
En otras palabras, "* al definir una variable de puntero" tiene un significado completamente diferente de "* al usar una variable de puntero".
detalles de la siguiente manera:
int *p = &a;
* p = 100;
En el primer código, * se usa para indicar que p es una variable de puntero
La segunda banda ah?El * se utiliza para obtener los datos apuntados por el puntero
"Cabe señalar que": al "asignar" la variable de puntero en sí, * no se puede agregar
como sigue:
int *p;
p = &a; // ¡Asigne un valor a la variable de puntero en sí! ! !
* p = 100;
Las variables de puntero también pueden aparecer en cualquier expresión donde puedan aparecer variables ordinarias, por ejemplo:
int x, y, *px = &x, *py = &y;
y = *px + 5; //Indica agregar 5 al contenido de x y asignarlo a y, *px+5 es equivalente a (*px)+5
y = ++*px; //Agregue 1 al contenido de px y asígnelo a y, ++*px es equivalente a ++(*px)
y = *px++; //equivalente a y=*(px++)
py = px; // asigna el valor de un puntero a otro puntero
Para que sea más fácil de entender para todos, ¡vamos a dar un ejemplo de programa a continuación!
//por ejemplo, intercambiar los valores de dos variables a través de punteros.
#include<stdio.h>
int main()
{
int a = 100,b = 999,temp;
int *pa = &a;
int *Pb = &b;
printf("a=%d,b=%d",a,b);
//进入交换！！！
temp = *pa; //将a的值先保存到temp上
*pa = *pb; //将b的值交给a；
*pb = temp；//最后将保存起来的a值交给b
//结束交换，输出最终结果
printf("a=%d,b=%d\n",a,b);
return 0;
}resultado:
a=100, b=999
a=999, b=100
Se puede ver a partir de los resultados de ejecución que los valores de a y b se han intercambiado. Cabe señalar que la variable temporal temp es muy importante, porque el valor de a será sobrescrito por el valor de b después de que se ejecute la sentencia *pa = *pb;, y no se encontrará si el valor de a es no guardado primero.
3. Rompecabezas sobre * y &
Supongamos que hay un tipo int a, pa es un puntero que los señala, entonces, ¿cuáles son los significados de *&a y *&pa respectivamente?
*&a puede entenderse como *(&a), &a significa "tomar la dirección de la variable a", que es equivalente a (pa), entonces *(&a) significa tomar los datos en esta dirección (equivalente a *pa), y dar la vuelta a Go, volver al punto original, *&a sigue siendo igual a a.
&*pa puede entenderse como &(*pa), *pa significa "obtener los datos señalados por pa (equivalente a a)", &(*pa) representa la dirección de los datos (equivalente a &a), por lo que & *pa etc. Con un precio de pa.
4. Resumen de asterisco*
En la gramática que hemos aprendido hasta ahora, el asterisco * tiene tres usos principales:
Indica multiplicación, como int a = 3, b = 5, c; c = a * b;, que es la más fácil de entender.
Indica la definición de una variable de puntero para distinguirla de las variables ordinarias, como int a = 100; int *p = &a;.
Indica la obtención de los datos señalados por el puntero, que es una operación indirecta, como int a, b, *p = &a; *p = 100; b = *p;.