Punteros en C:¿Qué es un puntero en la programación C? Tipos

¿Qué es el puntero en C?

El Puntero en C, es 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 incrementar/disminuir, es decir, para apuntar a 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 usar punteros en C

Si declaramos una variable v de tipo int, v en realidad almacenará un valor.

v es igual a cero ahora.

Sin embargo, cada variable, además del valor, también tiene su dirección (o, simplemente, dónde se encuentra en la memoria). La dirección se puede recuperar colocando un ampersand (&) antes del nombre de la variable.

Si imprime la dirección de una variable en la pantalla, se verá como un número totalmente aleatorio (además, puede ser diferente de una ejecución a otra).

Intentemos esto en la práctica con el puntero en el ejemplo de C

La salida de este programa es -480613588.

Ahora, ¿qué es un puntero? En lugar de almacenar un valor, un puntero almacenará la dirección de una variable.

Variable de puntero

Int *y =&v;

VARIABLEPOINTERA valor almacenado en un nombrado dirección de almacenamiento/memoriaA variable que apunta a la dirección de almacenamiento/memoria de otro variable

Declarar un puntero

Al igual que las variables, los punteros en la programación C deben declararse antes de que puedan usarse en su programa. Los punteros pueden tener el nombre que desee siempre que obedezcan las reglas de nomenclatura de C. Una declaración de puntero tiene la siguiente forma.

data_type * pointer_variable_name;

Aquí,

tipo_de_datos es el tipo base del puntero de los tipos de variables de C e indica el tipo de variable a la que apunta el puntero.
El asterisco (*:el mismo asterisco que se usa para la multiplicación), que es un operador indirecto, declara un puntero.

Veamos algunas declaraciones de puntero válidas en este tutorial de punteros C:

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 */

Inicializar un puntero

Después de declarar un puntero, lo inicializamos como variables estándar con una dirección variable. Si los punteros en la programación C no se inicializan y no se usan en el programa, los resultados son impredecibles y potencialmente desastrosos.

Para obtener la dirección de una variable, usamos el operador ampersand (&), colocado antes del nombre de una variable cuya dirección necesitamos. La inicialización del puntero se realiza con la siguiente sintaxis.

Sintaxis de puntero

 pointer = &variable;

A continuación se proporciona un programa simple para la ilustración del puntero:

#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:%x\n",p);  //accessing the address
   printf("Value stored in a variable p is:%d\n",*p);   //accessing the value
   return 0;
}

Salida:

Address stored in a variable p is:60ff08
Value stored in a variable p is:10

Operador Significado * Sirve para 2 propósitos

Declaración de un puntero
Devuelve el valor de la variable referenciada

&Sirve solo para 1 propósito

Devuelve la dirección de una variable

Tipos de Punteros en C

Los siguientes son los diferentes Tipos de punteros en C :

Puntero nulo

Podemos crear un puntero nulo asignando un valor nulo durante la declaración del puntero. Este método es útil cuando no tiene ninguna dirección asignada al puntero. Un puntero nulo siempre contiene el valor 0.

El siguiente programa ilustra 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;
}

Salida:

The value inside variable p is:
0

Puntero de vacío

En la programación C, un puntero vacío también se denomina puntero genérico. No tiene ningún tipo de datos estándar. Se crea un puntero de vacío utilizando la palabra clave void. Se puede utilizar para almacenar una dirección de cualquier variable.

El siguiente programa ilustra el uso de un puntero vacío:

#include <stdio.h>
int main()
{
void *p = NULL; 	//void pointer
printf("The size of pointer is:%d\n",sizeof(p));
return 0;
}

Salida:

The size of pointer is:4

Puntero salvaje

Se dice que un puntero es un puntero salvaje si no se inicializa en nada. Estos tipos de punteros C no son eficientes porque pueden apuntar a alguna ubicación de memoria desconocida que puede causar problemas en nuestro programa y puede provocar que el programa se cuelgue. Siempre se debe tener cuidado al trabajar con punteros salvajes.

El siguiente programa ilustra el uso del puntero salvaje:

#include <stdio.h>
int main()
{
int *p; 	//wild pointer
printf("\n%d",*p);
return 0;
}

Salida:

timeout: the monitored command dumped core
sh: line 1: 95298 Segmentation fault      timeout 10s main

Otros tipos de punteros en 'c' son los siguientes:

Puntero colgante
Puntero complejo
Puntero cercano
Puntero lejano
Enorme puntero

Puntero de acceso directo e indirecto

En C, hay dos formas equivalentes de acceder y manipular un contenido variable

Acceso directo:usamos directamente el nombre de la variable
Acceso indirecto:usamos un puntero a la variable

Entendamos 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("\n\nThe address of var = %d", &var);
printf("\nThe address of var = %d\n", 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 ningún error, 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 (precedencia)

Al trabajar con punteros C, debemos observar las siguientes reglas de prioridad:

Los operadores * y &tienen la misma prioridad que los operadores unarios (¡la negación!, el incremento++, el decremento–).
En la misma expresió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 donde se pueda escribir X.

Las siguientes expresiones son equivalentes:

entero X =10

int *P =&Y;

Para el código anterior, las siguientes expresiones son verdaderas

ExpresiónExpresión equivalenteY=*P+1

*P=*P+10

*P+=2

+****P

(*P)++

Y=X+1

X=X+10

X+=2

++X

X++

En este último caso, se necesitan paréntesis:como los operadores unarios * y ++ se evalúan de derecha a izquierda, sin los paréntesis 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 usar cuando se trata de punteros C

Operación Explicación Asignaciónint *P1,*P2
P1=P2;
P1 y P2 apuntan a la misma variable enteraIncremento y decrementoInt *P1;
P1++;P1–;Agregar un desplazamiento (Constante)Esto permite que el puntero mueva N elementos en una tabla.
El puntero se incrementará o disminuirá en N veces el número de bytes del tipo de la variable.
P1+5;

C punteros y matrices con ejemplos

Tradicionalmente, accedemos a los elementos de la matriz usando su índice, pero este método se puede eliminar usando punteros. Los punteros facilitan el acceso a cada elemento de la matriz.

#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 pointer\n");
    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;
}

Salida:

Agregar un número particular a un puntero moverá la ubicación del puntero al valor obtenido por una operación de suma. Supongamos que p es un puntero que actualmente apunta a la ubicación de memoria 0 si realizamos la siguiente operación de suma, p+1, entonces se ejecutará de esta manera:

Dado que p actualmente apunta a la ubicación 0 después de agregar 1, el valor se convertirá en 1 y, por lo tanto, el puntero apuntará a la ubicación de memoria 1.

C Punteros y cadenas con ejemplos

Una cadena es una matriz de objetos char, que termina con un carácter nulo '\ 0'. Podemos manipular cadenas usando punteros. 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:%c\n",*p);
p =p+1;
printf("Next character is:%c\n",*p);
printf("Printing all the characters in a string\n");
p=str;  //reset the pointer
for(int i=0;i<strlen(str);i++)
{
printf("%c\n",*p);
p++;
}
return 0;
}

Salida:

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 manejar cadenas es con una matriz de punteros 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("%s\n", materials[ i ]);}
  return 0;}

Salida:

Please remember these materials:
iron
copper
gold

Ventajas de los punteros en C

Los punteros son útiles para acceder a ubicaciones de memoria.
Los punteros proporcionan una forma eficiente de acceder a los elementos de una estructura de matriz.
Los punteros se utilizan tanto para la asignación dinámica de memoria como para la desasignación.
Los punteros se utilizan para formar estructuras de datos complejas, como listas enlazadas, gráficos, árboles, etc.

Desventajas de los punteros en C

Los punteros son un poco complejos de entender.
Los punteros pueden generar varios errores, como fallas de segmentación, o pueden acceder a una ubicación de memoria que no se requiere en absoluto.
Si se proporciona un valor incorrecto a un puntero, puede dañar la memoria.
Los punteros también son responsables de la pérdida de memoria.
Los punteros son comparativamente más lentos que los de las variables.
A los programadores les resulta muy difícil trabajar con los punteros; por lo tanto, es responsabilidad del programador manipular un puntero con cuidado.

Resumen:

Un puntero no es más que una ubicación de memoria donde se almacenan los datos.
Se utiliza un puntero para acceder a la ubicación de la memoria.
Hay varios tipos de punteros, como un puntero nulo, un puntero salvaje, un puntero vacío y otros tipos de punteros.
Los punteros se pueden usar con una matriz y una cadena para acceder a los elementos de manera más eficiente.
Podemos crear punteros de función para invocar una función dinámicamente.
Las operaciones aritméticas se pueden realizar en un puntero, lo que se conoce como aritmética de punteros.
Los punteros también pueden apuntar a una función, lo que facilita llamar a diferentes funciones en el caso de definir una matriz de punteros.
Cuando desee manejar diferentes tipos de datos variables, puede usar un puntero vacío tipocasteado.

Funciones en Programación C con Ejemplos:Recursiva e Inline Punteros de funciones en programación C con ejemplos

Lenguaje C