SizeOf Operator en lenguaje C

En este artículo, vamos a aprender sobre el operador de tamaño de. Es un operador unario ampliamente utilizado en el desarrollo de software integrado, que nos ayuda a descubrir el tamaño del operando. Por lo tanto, el valor de retorno del operador sizeOf nos ayuda a comprender el número de bytes asignados en la memoria de la computadora para mantener la variable particular o el tipo de datos.

Comprensión de tamaño de:

Antes de sumergirnos en la discusión del operador SizeOf, primero entendamos el significado del operador. Un operador está representado por un token o símbolo que se utiliza para realizar una operación como suma, resta, multiplicación, división, etc. sobre valores o variables (operandos). Por ejemplo, " *" es el símbolo que se usa para representar la operación de multiplicación, y funciona en dos operandos (resultado = a * b;). Este es un ejemplo de un operador binario.

Sin embargo, si un operador trabaja solo en un operando, llamamos a dicho operador como un operador unario. El operador sizeOf es uno de los operadores unarios que existen en el lenguaje de programación C y aparentemente, opera solo en un operando. El operador sizeOf devuelve el tamaño del operando. Eso significa que, del valor de retorno del operador sizeOf, podemos decir claramente cuántos bytes asignados para contener el operando particular en la memoria de la computadora.

La memoria de una computadora es una colección de unidades de memoria (yo.mi. byte). Cuando SeaTeOf (int) devuelve cuatro en un sistema informático en particular, podemos decir que una variable entera toma 4 bytes para mantener su valor en la memoria de ese sistema informático específico. Además, tenga en cuenta que el valor de retorno del operador sizeOf también depende de las máquinas que está utilizando (sistema de 32 bits o sistema de 64 bits).

Sintaxis:

Sizeof (tipo)
Sizeof (expresión)

El tipo de retorno de sizeof es size_t.

Ejemplos:

Ahora, dado que entendemos el operador sizeOf y conocemos la sintaxis, veamos un par de ejemplos, lo que nos ayudará a comprender el concepto de una mejor manera.

• Sizeof para tipos incorporados (ejemplo1.C)
• Sizeof para matriz (ejemplo2.C)
• SizeOf para tipos definidos por el usuario (ejemplo3.C)
• SizeOf para variables (Ejemplo4.C)
• SizeOf para la expresión (ejemplo5.C)
• Uso práctico de sizeof (ejemplo6.C)

Sizeof para tipos incorporados (ejemplo1.C):

En este programa, veremos cómo funciona el operador sizeOf para los tipos de datos incorporados como int, char, float, double. Veamos el programa y la salida.

#incluir
int main ()

printf ("tamaño de char = %ld \ n", sizeof (char));
printf ("tamaño de int = %ld \ n", sizeof (int));
printf ("tamaño de float = %ld \ n", sizeOf (float));
printf ("tamaño de doble = %ld \ n \ n", sizeOf (doble));
printf ("tamaño de short int = %ld \ n", sizeOf (short int));
printf ("tamaño de largo int = %ld \ n", sizeOf (long int));
printf ("tamaño de largo largo int = %ld \ n", sizeOf (largo long int));
printf ("tamaño de doble largo = %ld \ n", sizeOf (largo doble));
regresar 0;

Sizeof para matriz (ejemplo2.C)

En este programa, veremos cómo usar el operador sizeOf para diferentes tipos de matriz. En caso de una matriz, el operador sizeOf regresará (no. de elementos en la matriz * sizeOf (tipo de matriz)). Por ejemplo, cuando declaramos una matriz de tipo entero de 10 elementos (inteligentes int [10];), el tamaño de (teléfonos inteligentes) volverá:

(No. de elementos en teléfonos inteligentes * sizeof (int)) = (10 * 4) = 40

Veamos el programa y la salida.

#incluir
int main ()

int inteligente [10];
Char SmartPhonenames [10];
Double SmartPhonesPrice [10];
printf ("tamaño de int = %ld \ n", sizeof (int));
printf ("tamaño de char = %ld \ n", sizeof (char));
printf ("tamaño de doble = %ld \ n", sizeof (doble));
/* Averigua la matriz de tamaño*/
printf ("tamaño de los teléfonos inteligentes [10] = %ld \ n", sizeof (teléfonos inteligentes));
printf ("Tamaño de SmartPhoneNames [10] = %ld \ n", sizeOf (smartphoneenames));
printf ("tamaño de SmartPhonesPrice [10] = %ld \ n", sizeof (SmartPhonesPrice));
regresar 0;

SizeOf para tipos definidos por el usuario (ejemplo3.C):

En este ejemplo, veremos cómo usar el operador sizeOf para tipos de datos definidos por el usuario, como estructura y unión. Usemos el programa y comprendamos la salida.

Ahora, mirando el programa, y ​​podemos calcular manualmente el tamaño de SmartPhonetype. Como puede ver a continuación, SmartPhonetype es una estructura, y contiene los siguientes elementos:

• Número de variable de tipo de caracteres = 1 [sp_name]
• Número de variable de tipo entero = 1 [SP_VERSION]
• Número de variables de tipo flotante = 3 [sp_length, sp_width, sp_height]

Del Ejemplo-1, lo hemos visto:

• • El tamaño del carácter es 1 byte
  • El tamaño de un entero es 4 bytes
  • El tamaño de un flotador es de 4 bytes

Por lo tanto, si suman el tamaño de todos los elementos de la estructura, deberíamos poder obtener el tamaño de la estructura, i.mi. Smartphonetype. Por lo tanto, el tamaño de la estructura debe ser = (1 + 4 + 4 + 4 + 4) bytes = 17 bytes. Sin embargo, la salida del programa dice que el tamaño de la estructura es 20. Los 3 bytes adicionales (sp_name, que es un personaje, está tomando 4 bytes en lugar de 1 byte) asignados para la estructura debido a la estructura relleno.

#incluir
/* Crear un tipo de estructura definida por el usuario - SmartPhonetype*/
struct smartphonetype

char sp_name;
int sp_version;
flotante sp_length;
flotante sp_width;
flotante sp_height;
Teléfono inteligente;
/* Definir un tipo de unión definido por el usuario - SmartPhoneSunionType*/
Union SmartPhoneSunionType

char sp_name;
int sp_version;
flotante sp_length;
flotante sp_width;
flotante sp_height;
Smartphone_u;
int main ()

/* Descubra el tamaño de la estructura y la unión*/
printf ("tamaño de struct = %ld \ n", sizeof (teléfono inteligente));
printf ("tamaño de union = %ld \ n", sizeof (smartphone_u));
regresar 0;

SizeOf para variables (Ejemplo4.C):

Este programa de ejemplo ilustra que el operador sizeOf es capaz de aceptar la variable también y devolver el tamaño de la variable.

#incluir
int main ()

/ * Declarar char, int, flotante y tipo doble variable y matriz */
char var_a, var_b [20];
int var_c, var_d [20];
float var_e, var_f [20];
doble var_g, var_h [20];
/* Descubra el tamaño de las variables y la matriz.
Este programa demuestra que la variable también puede
ser utilizado como operador de operando de operador*/
/* Tamaño de Char, Char Variable y Char Array*/
printf ("tamaño de char = %ld \ n", sizeof (char));
printf ("tamaño de var_a = %ld \ n", sizeOf (var_a));
printf ("tamaño de var_b [20] = %ld \ n \ n", sizeof (var_b));
/* Tamaño de int, int variable e int Array*/
printf ("tamaño de int = %ld \ n", sizeof (int));
printf ("tamaño de var_c = %ld \ n", sizeof (var_c));
printf ("tamaño de var_d [20] = %ld \ n \ n", sizeof (var_d));
/* Tamaño del flotador, variable flotante y matriz de flotación*/
printf ("tamaño de float = %ld \ n", sizeOf (float));
printf ("tamaño de var_e = %ld \ n", sizeof (var_e));
printf ("tamaño de var_f [20] = %ld \ n \ n", sizeof (var_f));
/* tamaño de doble, doble variable y matriz doble*/
printf ("tamaño de doble = %ld \ n", sizeof (doble));
printf ("tamaño de var_g = %ld \ n", sizeof (var_g));
printf ("tamaño de var_h [20] = %ld \ n", sizeOf (var_h));
regresar 0;

SizeOf para la expresión (ejemplo5.C):

En este programa de ejemplo, demostraremos que el operador sizeOf también puede aceptar una expresión y devolver el tamaño de la expresión resultante.

#incluir
int main ()

int var_a = 5, var_b = 3;
doble var_c = 2.5, var_d = 4.5;
printf ("tamaño de int = %ld \ n", sizeof (int));
printf ("tamaño de doble = %ld \ n \ n", sizeOf (doble));
printf ("tamaño de var_a * var_b = %ld \ n", sizeof (var_a * var_b));
printf ("tamaño de var_c * var_d = %ld \ n", sizeof (var_c * var_d));
/* Aquí estamos multiplicando una variable entera con una doble variable.
Por lo tanto, el operador sizeOf devolverá el tamaño de máximo de tamaño
variable yo.mi. variable de doble tipo.*/
printf ("tamaño de var_a * var_c = %ld \ n", sizeof (var_a * var_c));
regresar 0;

Uso práctico de sizeof (ejemplo6.C):

Este programa de ejemplo lo ayudará a comprender un caso de uso práctico del operador SizeOf. El operador sizeOf es muy útil al asignar la memoria dinámica del montón usando malloc. Veamos el programa y la salida.

#incluir
#incluir
estructura typedef

char sp_name;
int sp_version;
flotante sp_length;
flotante sp_width;
flotante sp_height;
SmartPhonetype;
int main ()

/* Asignar memoria en la memoria del montón para mantener cinco smartphonetype
variables.
*/
SmartPhonetype * smartphone_ptr = (smartphonetype *) malloc (5 * sizeof (smartphonetype));
if (smartphone_ptr != Nulo)

printf ("Memoria asignada para 5 variables de estructura SmartPhonetype en
la memoria del montón.\norte");

demás

printf ("El error ocurrió durante la asignación de memoria del montón!");

regresar 0;

Conclusión:

El sizeOf es un operador unario importante en el lenguaje de programación C. Nos ayuda a determinar el tamaño de los tipos de datos primitivos, los tipos de datos definidos por el usuario, las expresiones, etc. en la memoria de la computadora. El operador SizeOf juega un papel importante en la asignación de la memoria dinámica en C usando Malloc, Calloc, etc. En la memoria del montón.