¿Qué es un puntero en C?
El es Consejo en C, una variable que almacena la dirección de otra variable. Un puntero también se puede utilizar para hacer referencia a otra función de puntero. Un puntero se puede aumentar / disminuir, es decir, para enfocarse en la ubicación de memoria siguiente / anterior. El propósito del puntero es ahorrar espacio en la memoria y lograr un tiempo de ejecución más rápido.
Cómo utilizar las sugerencias en C.
Si declaramos una variable v de tipo int, v realmente almacenará un valor.
v es igual a cero ahora.
Sin embargo, cada variable, en lugar de un valor, tiene su dirección (o, simplemente, dónde se encuentra en la memoria). La dirección se puede recuperar poniendo un ampersand (&) antes del nombre de la variable.
Si imprime una dirección variable en la pantalla, se verá como un número aleatorio (además, puede diferir de una ejecución a otra).
Intentemos esto prácticamente con un puntero en el ejemplo C.
La salida de este programa es -480613588.
Ahora bien, ¿qué es un puntero? En lugar de almacenar un valor, un puntero almacenará una dirección de variable.
Puntero variable
Int * y = & v;
APLICABLE | PUNTERO |
UNA. valor guardado en llamado dirección de almacenamiento / memoria | UNA. variable a puntos a dirección de almacenamiento / memoria otro variable |
Sugerencia de confirmación
Al igual que las variables, las sugerencias en la programación en C deben confirmarse antes de que puedan usarse en su programa. Las sugerencias se pueden nombrar como usted quiera siempre que se adhieran a las reglas de nomenclatura de C. El siguiente formulario es una declaración de puntero.
data_type * pointer_variable_name;
Seo
- tipo de datos el tipo básico del puntero es el tipo de variable C e indica el tipo de variable al que apunta el puntero.
- Declara que el asterisco (*: el mismo asterisco utilizado para la multiplicación) es un operador de direccionamiento indirecto de puntero.
Veremos algunas declaraciones de puntero válidas en este tutorial de C-tips:
int *ptr_thing; /* pointer to an integer */ int *ptr1,thing;/* ptr1 is a pointer to type integer and thing is an integer variable */ double *ptr2; /* pointer to a double */ float *ptr3; /* pointer to a float */ char *ch1 ; /* pointer to a character */ float *ptr, variable;/*ptr is a pointer to type float and variable is an ordinary float variable */
Empiece con un puntero
Después de declarar un puntero, lo iniciamos como variables estándar con una dirección de variable. Si los consejos en la programación C no se identifican y se utilizan en el programa, los resultados son predecibles y potencialmente desastrosos.
Para obtener una dirección de variable, usamos el operador comercial (&), que está precedido por el nombre de una variable cuya dirección necesitamos. Los frentes de puntero están hechos con la siguiente sintaxis.
La sintaxis del puntero
pointer = &variable;
A continuación se proporciona un programa sencillo para la representación de punteros:
#include <stdio.h>
int main()
{
int a=10; //variable declaration
int *p; //pointer variable declaration
p=&a; //store address of variable a in pointer p
printf("Address stored in a variable p is:%xn",p); //accessing the address
printf("Value stored in a variable p is:%dn",*p); //accessing the value
return 0;
}
Producción:
Address stored in a variable p is:60ff08 Value stored in a variable p is:10
| Operador | Significado |
| * | Sirve para 2 propósitos
|
| Y | Sirve solo para un propósito
|
Tipos de consejos en C.
Aquí están los diferentes Tipos de consejos en C.:
Puntero vacío
Podemos crear un puntero nulo asignando un valor nulo durante la declaración del puntero. Este método es útil cuando no se asigna ninguna dirección al puntero. Un puntero nulo siempre tiene un valor de 0.
El siguiente programa muestra el uso de un puntero nulo:
#include <stdio.h>
int main()
{
int *p = NULL; //null pointer
printf(“The value inside variable p is:n%x”,p);
return 0;
}
Producción:
The value inside variable p is: 0
Pista de vacío
I Registro C., un puntero vacío también se denomina puntero genérico. No hay un tipo de datos estándar. Un puntero nulo se crea utilizando la palabra clave null. Puede usarse para almacenar la dirección de cualquier variable.
El siguiente programa muestra el uso de un puntero nulo:
#include <stdio.h>
int main()
{
void *p = NULL; //void pointer
printf("The size of pointer is:%dn",sizeof(p));
return 0;
}
Producción:
The size of pointer is:4
Puntero salvaje
Se dice que un puntero es un puntero salvaje si no comienza en nada. Estos tipos de C-tips no son efectivos porque pueden apuntar a una ubicación de memoria desconocida que podría crear problemas en nuestro programa y el programa podría deteriorarse. Siempre se debe tener cuidado al trabajar con puntas salvajes.
El siguiente programa demuestra el uso de un puntero salvaje:
#include <stdio.h>
int main()
{
int *p; //wild pointer
printf("n%d",*p);
return 0;
}
Producción
timeout: the monitored command dumped core sh: line 1: 95298 Segmentation fault timeout 10s main
Otros tipos de pistas en ‘c’ son:
- Puntero peligroso
- Puntero complejo
- Junto a un puntero
- Mucho puntero
- Puntero enorme
Consejos de acceso directo e indirecto
IC, hay dos formas equivalentes de acceder y manipular contenido variable
- Acceso directo: usamos el nombre de la variable directamente
- Acceso indirecto: usamos un puntero para la variable
Entendemos esto con la ayuda del programa a continuación
#include <stdio.h>
/* Declare and initialize an int variable */
int var = 1;
/* Declare a pointer to int */
int *ptr;
int main( void )
{
/* Initialize ptr to point to var */
ptr = &var;
/* Access var directly and indirectly */
printf("nDirect access, var = %d", var);
printf("nIndirect access, var = %d", *ptr);
/* Display the address of var two ways */
printf("nnThe address of var = %d", &var);
printf("nThe address of var = %dn", ptr);
/*change the content of var through the pointer*/
*ptr=48;
printf("nIndirect access, var = %d", *ptr);
return 0;}Después de compilar el programa sin errores, el resultado es:
Direct access, var = 1 Indirect access, var = 1 The address of var = 4202496 The address of var = 4202496 Indirect access, var = 48
Aritmética de punteros en C.
Las operaciones del puntero se resumen en la siguiente figura
Operación prioritaria (prioridad)
Al trabajar con los consejos C, debemos seguir las siguientes reglas de prioridad:
- Los operadores * y & los operadores unarios tienen la misma prioridad (¡negligencia!, Incremento ++, disminución–).
- En la misma oración, los operadores unarios *, &,!, ++, – se evalúan de derecha a izquierda.
Si un puntero P apunta a una variable X, entonces * P se puede usar siempre que se pueda escribir X.
Las siguientes oraciones son:
| int X = 10 int * P = & Y; Para el código anterior, las expresiones siguientes son verdaderas | |
| Slonn | Expresión equivalente |
| Y = * P + 1 * P = * P + 10 * P + = 2 ++ * P. (* P) ++ | Y = X + 1 X = X + 10 X + = 2 ++ X. X ++ |
En el último caso, se requieren paréntesis: dado que los operadores unarios * y ++ se evalúan de derecha a izquierda, sin los corchetes se incrementaría el puntero P, no el objeto al que apunta P.
La siguiente tabla muestra la operación aritmética y básica que se puede utilizar al tratar con pistas C.
| Operación | Explicación |
| Tarea | int * P1, * P2 P1 = P2; P1 y P2 apuntan a la misma variable entera |
| Aumentar y disminuir | Int * P1; P1 ++; P1–; |
| Agregar compensación (constante) | Esto permite que el puntero mueva N elementos en una tabla. El puntero debajo de N aumentará o disminuirá en el número de bytes / medidas del tipo de variable. P1 + 5; |
C Consejos y edición con ejemplos
Tradicionalmente, accedemos a los elementos de la matriz usando su índice, pero este método se puede eliminar usando punteros. Los sencillos consejos hacen que todas las funciones de edición sean accesibles.
#include <stdio.h>
int main()
{
int a[5]={1,2,3,4,5}; //array initialization
int *p; //pointer declaration
/*the ptr points to the first element of the array*/
p=a; /*We can also type simply ptr==&a[0] */
printf("Printing the array elements using pointern");
for(int i=0;i<5;i++) //loop for traversing array elements
{
printf("n%x",*p); //printing array elements
p++; //incrementing to the next element, you can also write p=p+1
}
return 0;
}
Producción
1 2 3 4 5
Agregar un cierto número a un puntero moverá la posición del puntero al valor obtenido por una operación adicional. Supongamos que pa es un puntero que actualmente apunta a la ubicación de la memoria 0, si lo hacemos después de una operación de aumento, p + 1 se ejecutará de esta manera:
Dado que p apunta a la posición 0 actual después de sumar 1, el valor es 1, por lo que el puntero apuntará a la ubicación de memoria de 1.
Consejos y cadenas de C con ejemplos
Una cadena es una cadena de artículos de caracteres que termina en un carácter nulo ‘ 0’. Podemos manipular cadenas mediante indicaciones. Este puntero en el ejemplo C explica esta sección
#include <stdio.h>
#include <string.h>
int main()
{
char str[]="Hello Guru99!";
char *p;
p=str;
printf("First character is:%cn",*p);
p =p+1;
printf("Next character is:%cn",*p);
printf("Printing all the characters in a stringn");
p=str; //reset the pointer
for(int i=0;i<strlen(str);i++)
{
printf("%cn",*p);
p++;
}
return 0;
}
Producción
First character is:H Next character is:e Printing all the characters in a string H e l l o G u r u 9 9 !
Otra forma de lidiar con las cadenas es con un conjunto de consejos como en el siguiente programa:
#include <stdio.h>
int main(){
char *materials[ ] = { "iron", "copper", "gold"};
printf("Please remember these materials :n");
int i ;
for (i = 0; i < 3; i++) {
printf("%sn", materials[ i ]);}
return 0;}
Producción:
Please remember these materials: iron copper gold
Ventajas de las puntas en C.
- Hay consejos útiles para acceder a las ubicaciones de la memoria.
- Los consejos proporcionan una forma eficaz de acceder a las funciones de una estructura de matriz.
- Las sugerencias se utilizan para la asignación dinámica de memoria y para la desasignación.
- Las sugerencias se utilizan para formar estructuras de datos complejas, como una lista vinculada, un gráfico, un árbol, etc.
Desventajas de las puntas en C.
- Las pistas son un poco complicadas de entender.
- Sugerencias, como fallas en las particiones, pueden provocar varios errores o pueden acceder a una ubicación de memoria no deseada.
- Si se proporciona un valor incorrecto a un puntero, puede dañar la memoria.
- Las pistas también son responsables de la pérdida de memoria.
- Las sugerencias son más lentas que las variables.
- A los programadores les resulta muy difícil trabajar con las sugerencias; por lo que es responsabilidad del programador manipular un puntero con cuidado.
Resumen
- Un puntero es solo una ubicación de la memoria donde se almacenan los datos.
- Se utiliza un puntero para acceder a la ubicación de la memoria.
- Hay diferentes tipos de punteros como puntero nulo, puntero salvaje, puntero nulo y otros tipos de punteros.
- Las sugerencias se pueden usar con cadenas y cadenas para acceder a los elementos de una manera más eficiente.
- Podemos crear solicitudes de función para invocar dinámicamente una función.
- Las operaciones aritméticas se pueden realizar en un puntero llamado aritmética de puntero.
- Las sugerencias también pueden centrarse en una función que facilita la llamada a diferentes funciones para definir un conjunto de sugerencias.
- Cuando desee manejar diferentes tipos de datos variables, puede usar un puntero nulo encasillado.