Obtener el tamaño de un puntero en C

1. Punteros en lenguaje de programación C
2. Usa el método sizeof() para obtener el tamaño de un puntero en C
3. Utilice el método malloc() para obtener el tamaño de un puntero en C

Este artículo demuestra cómo determinar el tamaño de un puntero utilizando el lenguaje de programación C.

Punteros en lenguaje de programación C

Una variable conocida como puntero es aquella cuyo valor es la dirección de otra variable; en otras palabras, el puntero mismo contiene la dirección directa de la ubicación de memoria. Antes de que se pueda usar un puntero para mantener la ubicación de una variable, primero se debe declarar.

Sintaxis:

type *var - name;

Aquí, el tipo se refiere al tipo base del puntero, debe ser un tipo de datos válido, y el var-name es el nombre de la variable que almacena el puntero. Es importante tener en cuenta que el asterisco (*) que se usa para designar un puntero es el mismo asterisco que se usa para la multiplicación.

Por otro lado, el asterisco(*) se usa en esta oración para indicar que una variable en particular es un puntero. Las siguientes son algunas de las diferentes declaraciones de tipos de datos aceptables para los punteros.

int *integerPointer;
char *characterPointer;
float *floatPointer;
double *doublePointer;

Usa el método sizeof() para obtener el tamaño de un puntero en C

El método sizeof() solo acepta un parámetro. Es un operador cuyo valor lo determina el compilador; por este motivo, se denomina operador unario en tiempo de compilación.

La función sizeof() devuelve el tipo de datos integral sin signo.

Veamos un ejemplo en el que usaremos la función sizeof() para determinar el tamaño de varias variables cuyos tipos de datos difieren. Establezca los valores iniciales para cuatro variables denominadas a,, b,, c, y d utilizando los tipos de datos int,, char,, float, y double,, respectivamente.

int a = 10;
char b = 'x';
float c = 10.01;
double d = 10.01;

Después de inicializar las cuatro variables de puntero con los nombres *integerPointer,, *characterPointer,, *floatPointer, y *doublePointer,, asigne los valores a, b, c y d a ellos respectivamente.

int *integerPointer = &a;
char *characterPointer = &b;
float *floatPointer = &c;
double *doublePointer = &d;

Ahora, necesitamos algunos comandos printf para generar el tamaño de las variables y las variables de puntero.

Estas declaraciones son necesarias para utilizar el operador sizeof, y los parámetros que se le deben proporcionar son a,, b,, c,, d y, en consecuencia, *integerPointer,, *characterPointer,, *punto flotante, y *puntodoble.

printf("size of (a) = %lu bytes", sizeof(a));
printf("\nsize of (a) pointer = %lu bytes", sizeof(*integerPointer));

printf("\nsize of (b) = %lu bytes", sizeof(b));
printf("\nsize of (b) pointer = %lu bytes", sizeof(*characterPointer));

printf("\nsize of (c) = %lu bytes", sizeof(c));
printf("\nsize of (c) pointer = %lu bytes", sizeof(*floatPointer));

printf("\nsize of (d) = %lu bytes", sizeof(d));
printf("\nsize of (d) pointer = %lu bytes", sizeof(*doublePointer));

Se utiliza la notación %lu porque el resultado del método sizeof es un entero sin signo.

Código fuente completo:

#include <stdio.h>

int main() {
  int a = 10;
  char b = 'x';
  float c = 10.01;
  double d = 10.01;

  int *integerPointer = &a;
  char *characterPointer = &b;
  float *floatPointer = &c;
  double *doublePointer = &d;

  printf("size of (a) = %lu bytes", sizeof(a));
  printf("\nsize of (a) pointer = %lu bytes", sizeof(*integerPointer));

  printf("\nsize of (b) = %lu bytes", sizeof(b));
  printf("\nsize of (b) pointer = %lu bytes", sizeof(*characterPointer));

  printf("\nsize of (c) = %lu bytes", sizeof(c));
  printf("\nsize of (c) pointer = %lu bytes", sizeof(*floatPointer));

  printf("\nsize of (d) = %lu bytes", sizeof(d));
  printf("\nsize of (d) pointer = %lu bytes", sizeof(*doublePointer));

  return 0;
}

Producción :

size of (a): = 4 bytes
size of (a) pointer: = 4 bytes
size of (b): = 1 bytes
size of (b) pointer: = 1 bytes
size of (c): = 4 bytes
size of (c) pointer: = 4 bytes
size of (d): = 8 bytes
size of (d) pointer: = 8 bytes

Utilice el método malloc() para obtener el tamaño de un puntero en C

Veamos un ejemplo más de una variable puntero, utilizando la técnica malloc para asignar el tamaño.

Dentro de la función main(), inicie una variable puntero con el tipo de datos char y asígnele el nombre *cPointer. Asigne una función con el nombre malloc() y proporcione el método sizeof() como argumento.

El método sizeof acepta char * como argumento.

int main() { char *cPointer = malloc(sizeof(char *)); }

En este punto, debemos imprimir el valor de *cPointer en bytes.

printf("Size of the pointer is %lu bytes.\n", sizeof(*cPointer));

Código fuente completo:

#include <stdio.h>
#include <stdlib.h>

int main() {
  char *cPointer = malloc(sizeof(char *));
  printf("Size of the pointer is %lu bytes.\n", sizeof(*cPointer));

  return 0;
}

Producción :

The size of the pointer is 1 byte.