Expresiones de puntero en C con ejemplos

Prerrequisito: Punteros en C

Los punteros se utilizan para señalar la dirección de la ubicación de una variable. Un puntero se declara precediendo el nombre del puntero por un asterisco (*) .
Sintaxis:

datatype *pointer_name;

Cuando necesitamos inicializar un puntero con la ubicación de la variable, usamos el signo ampersand (&) antes del nombre de la variable.
Ejemplo:

// Declaration of integer variable
int var=10;
  
// Initialization of pointer variable
int *pointer=&var;

El ampersand (&) se usa para obtener la dirección de una variable. Podemos encontrar directamente la ubicación de cualquier identificador simplemente precediéndolo con un signo de y comercial (&).
Ejemplo:

// This code prints the address of x
#include <stdio.h>
  
int main()
{
    int x = 10;
  
    // Prints address of x
    printf(
        "Address of variable x = %p", &x);
  
    return 0;
}

Address of variable x = 0x7fff3b690fd4

C admite un amplio conjunto de operaciones integradas como aritméticas, relacionales, de asignación, condicionales, etc. que se pueden realizar en los identificadores. Al igual que cualquier otra variable, estas operaciones también se pueden realizar en variables de puntero .

Operadores aritméticos

Podemos realizar operaciones aritméticas con variables de puntero usando operadores aritméticos. Podemos sumar un número entero o restar un número entero usando un puntero que apunte a esa variable entera. La tabla dada muestra los operadores aritméticos que se pueden realizar en las variables de puntero:

Ejemplos:

*ptr1 + *ptr2
*ptr1 * *ptr2
*ptr1 + *ptr2 - *ptr3

También podemos realizar directamente expresiones aritméticas utilizando números enteros. Veamos el ejemplo que se da a continuación, donde p1 y p2 son punteros.

p1+10, p2-5, p1-p2+10, p1/2 

El siguiente diagrama representa cómo funcionan exactamente las expresiones/operadores con punteros.

Como se ve en el diagrama, el puntero ‘pa’ y ‘pb’ apunta a la variable entera ‘a’ y ‘b’ respectivamente. La suma se realiza directamente entre las variables enteras y la variable puntero y los resultados se almacenan en las variables enteras ‘c’ y ‘x’ respectivamente. Ambos resultados son iguales.

Entendamos mejor la expresión aritmética de punteros con el código dado:

// Program showing pointer expressions
// during Arithmetic Operations
#include <stdio.h>
  
int main()
{
    // Integer variables
    int a = 20, b = 10;
  
    // Variables for storing arithmetic
    // operations solution
    int add, sub, div, mul, mod;
  
    // Pointer variables for variables
    // a and b
    int *ptr_a, *ptr_b;
  
    // Initialization of pointers
    ptr_a = &a;
    ptr_b = &b;
  
    // Performing arithmetic Operations
    // on pointers
    add = *ptr_a + *ptr_b;
    sub = *ptr_a - *ptr_b;
    mul = *ptr_a * *ptr_b;
    div = *ptr_a / *ptr_b;
    mod = *ptr_a % *ptr_b;
  
    // Printing values
    printf("Addition = %d\n", add);
    printf("Subtraction = %d\n", sub);
    printf("Multiplication = %d\n", mul);
    printf("Division = %d\n", div);
    printf("Modulo = %d\n", mod);
    return 0;
}

Addition = 30
Subtraction = 10
Multiplication = 200
Division = 2
Modulo = 0

Nota: Mientras realiza la división, asegúrese de dejar un espacio en blanco entre ‘/’ y ‘*’ del puntero, ya que juntos formarían un comentario de varias líneas (‘/*’).
Ejemplo:

 Incorrect:  *ptr_a/*ptr_b;
 Correct:    *ptr_a / *ptr_b; 
 Correct:    (*ptr_a)/(*ptr_b);

Operadores relacionales

Las operaciones relacionales se utilizan a menudo para comparar los valores de la variable en función de la cual podemos tomar decisiones. La tabla dada muestra los operadores relacionales que se pueden realizar en las variables de puntero. Ejemplo:

*ptr1 > *ptr2
*ptr1 < *ptr2

El valor de la expresión relacional es 0 o 1 que es falso o verdadero. La expresión devolverá el valor 1 si la expresión es verdadera y devolverá el valor 0 si es falsa.

Entendamos mejor la expresión relacional en el puntero con el siguiente código:

// Program showing pointer expressions
// during Relational Operations
#include <stdio.h>
int main()
{
    // Initializing integer variables
    int a = 20, b = 10;
  
    // Declaring pointer variables
    int* ptr_a;
    int* ptr_b;
  
    // Initializing pointer variables
    ptr_a = &a;
    ptr_b = &b;
  
    // Performing relational operations
    // less than operator
    if (*ptr_a < *ptr_b) {
        printf(
            "%d is less than %d.", *ptr_a, *ptr_b);
    }
  
    // Greater than operator
    if (*ptr_a > *ptr_b) {
        printf(
            "%d is greater than %d.", *ptr_a, *ptr_b);
    }
  
    // Equal to
    if (*ptr_a == *ptr_b) {
        printf(
            "%d is equal to %d.", *ptr_a, *ptr_b);
    }
  
    return 0;
}

20 is greater than 10.

Producción:

20 is greater than 10.

Operadores de Asignación

Los operadores de asignación se utilizan para asignar valores a los identificadores. Hay varias operaciones abreviadas disponibles. A continuación se proporciona una tabla que muestra la declaración de asignación real con su declaración abreviada. Ejemplos:

*a=10
*b+=20
*z=3.5
*s=4.56743

Entendamos mejor el operador de asignación con la ayuda del código que se muestra a continuación:

// Program showing pointer expressions
// during Assignment Operations
#include <stdio.h>
int main()
{
    // Initializing integer variable
    int a = 30;
  
    // Declaring pointer variable
    int* ptr_a;
  
    // Initializing pointer using
    // assignment operator
    ptr_a = &a;
  
    // Changing the variable's value using
    // assignment operator
    *ptr_a = 50;
  
    // Printing value of 'a' after
    // updating its value
    printf("Value of variable a = %d", *ptr_a);
  
    return 0;
}

Value of variable a = 50

Operadores Condicionales

Solo hay un operador condicional utilizado principalmente en C conocido como operador ternario. El operador ternario primero verifica la expresión y, según su valor devuelto, devuelve verdadero o falso, lo que activa/selecciona otra expresión.

Sintaxis:

expression1 ? expression2 : expression3;

Ejemplo:

c = (*ptr1 > *ptr2) ? *ptr1 : *ptr2;

• Como se muestra en el ejemplo, suponiendo *ptr1=20 y *ptr2=10, la condición aquí se vuelve verdadera para la expresión, por lo que devolverá el valor de la expresión verdadera, es decir, *ptr1, por lo que la variable ‘c’ ahora contendrá el valor de 20.
• Considerando el mismo ejemplo, suponga que *ptr1=30 y *ptr2=50, entonces la condición es falsa para la expresión, por lo que devolverá el valor de la expresión falsa, es decir, *ptr2, por lo que la variable ‘c’ ahora contendrá el valor 50.

Entendamos el concepto a través del código dado:

// Program showing pointer expressions
// during Conditional Operations
#include <stdio.h>
int main()
{
    // Initializing integer variables
    int a = 15, b = 20, result = 0;
  
    // Declaring pointer variables
    int *ptr_a, *ptr_b;
  
    // Initializing pointer variables
    ptr_a = &a;
    ptr_b = &b;
  
    // Performing ternary operator
    result = ((*ptr_a > *ptr_b) ? *ptr_a : *ptr_b);
  
    // Printing result of ternary operator
    printf("%d is the greatest.", result);
    return 0;
}

20 is the greatest.

Operadores unarios

Hay principalmente dos operadores que se dan de la siguiente manera.

Ejemplos:

(*ptr1)++
(*ptr1)--

Entendamos el uso del operador unario a través del código dado:

// Program showing pointer expressions
// during Unary Operations
#include <stdio.h>
int main()
{
    // Initializing integer variable
    int a = 34;
  
    // Declaring pointer variable
    int* ptr_a;
  
    // Initializing pointer variable
    ptr_a = &a;
  
    // Value of a before increment
    printf("Increment:\n");
    printf(
        "Before increment a = %d\n", *ptr_a);
  
    // Unary increment operation
    (*ptr_a)++;
  
    // Value of a after increment
    printf(
        "After increment a = %d", *ptr_a);
  
    // Value before decrement
    printf("\n\nDecrement:\n");
    printf(
        "Before decrement a = %d\n", *ptr_a);
  
    // unary decrement operation
    (*ptr_a)--;
  
    // Value after decrement
    printf("After decrement a=%d", *ptr_a);
  
    return 0;
}

Increment:
Before increment a = 34
After increment a = 35

Decrement:
Before decrement a = 35
After decrement a=34

Operadores bit a bit

Los operadores binarios también se conocen como operadores bit a bit. Se utiliza para manipular datos a nivel de bit. Los operadores bit a bit no se pueden usar para tipos de datos flotantes y dobles. A continuación se muestra una tabla con todos los operadores bit a bit:

Ejemplos:

*ptr1 & *ptr2
*ptr1 | *ptr2
*ptr1 ^ *ptr2

Entendamos el concepto a través del código dado:

// Program showing pointer expressions
// during Bitwise Operations
#include <stdio.h>
int main()
{
    // Declaring integer variable for
    // storing result
    int and, or, ex_or;
  
    // Initializing integer variable
    int a = 1, b = 2;
  
    // Performing bitwise operations
    // AND operation
    and = a & b;
  
    // OR operation
    or = a | b;
  
    // EX-OR operation
    ex_or = a ^ b;
  
    // Printing result of operations
    printf("\na AND b = %d", and);
    printf("\na OR b = %d", or);
    printf("\na Exclusive-OR b = %d", ex_or);
    return 0;
}

a AND b = 0
a OR b = 3
a Exclusive-OR b = 3