Saltar al contenido

¿Qué es el puntero, tipos y ejemplos?

¿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

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
OperadorSignificado
*Sirve para 2 propósitos

  1. Declaración de puntero
  2. Devuelve el valor de la variable de referencia.
YSirve solo para un propósito

  • Se devuelve la dirección variable

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:

Consejos de acceso directo e indirecto

IC, hay dos formas equivalentes de acceder y manipular contenido 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

Operaciones de puntero

Operación prioritaria (prioridad)

Al trabajar con los consejos C, debemos seguir las siguientes reglas de prioridad:

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

SlonnExpresió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ónExplicación
Tareaint * P1, * P2 P1 = P2; P1 y P2 apuntan a la misma variable entera
Aumentar y disminuirInt * 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:

Mejora / aumento del puntero

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.

Desventajas de las puntas en C.

Resumen

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *