Phenquestions
Comprensión del tamaño de:
Antes de sumergirnos en el tamaño de la discusión del operador, primero comprendamos el significado del operador. Un operador está representado por una ficha 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 con dos operandos (resultado = a * b;). Este es un ejemplo de un operador binario.
Sin embargo, si un operador trabaja con un solo operando, lo llamamos 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, a partir 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 (i.mi. byte). Cuando sizeof (int) devuelve cuatro en un sistema informático en particular, podemos decir que una variable entera necesita 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 que entendemos el operador sizeof y conocemos la sintaxis, veamos un par de ejemplos, que nos ayudarán a entender el concepto de una mejor manera.
- Sizeof para tipos integrados (ejemplo1.C)
- Sizeof para Array (ejemplo2.C)
- Sizeof para tipos definidos por el usuario (ejemplo3.C)
- Sizeof para variables (ejemplo4.C)
- Sizeof para expresión (ejemplo5.C)
- Uso práctico de sizeof (ejemplo6.C)
Sizeof para tipos integrados (ejemplo1.C):
En este programa, veremos cómo funciona el operador sizeof para tipos de datos integrados como int, char, float, double. Veamos el programa y la salida.
#incluirint main ()
printf ("Tamaño de char =% ld \ n", sizeof (char));
printf ("Tamaño de int =% ld \ n", sizeof (int));
printf ("Tamaño de flotante =% ld \ n", tamaño de (flotante));
printf ("Tamaño de doble =% ld \ n \ n", tamaño de (doble));
printf ("Tamaño de int corto =% ld \ n", sizeof (int corto));
printf ("Tamaño de int largo =% ld \ n", tamaño de (int largo));
printf ("Tamaño de long long int =% ld \ n", sizeof (long long int));
printf ("Tamaño de doble largo =% ld \ n", tamaño de (doble largo));
return 0;
Sizeof para Array (ejemplo2.C)
En este programa, veremos cómo usar el operador sizeof para diferentes tipos de arreglos. En el caso de una matriz, el operador sizeof devolverá (No. de elementos en la matriz * Sizeof (tipo de matriz)). Por ejemplo, cuando declaramos una matriz de tipo entero de 10 elementos (int SmartPhones [10];), el tamaño de (Smartphones) devolverá:
(No. de elementos en SmartPhones * sizeof (int)) = (10 * 4) = 40Veamos el programa y la salida.
#incluirint main ()
int SmartPhones [10];
char SmartPhoneNames [10];
doble 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", tamaño de (doble));
/ * Averigua el tamaño de Array * /
printf ("Tamaño de SmartPhones [10] =% ld \ n", tamaño de (SmartPhones));
printf ("Tamaño de SmartPhoneNames [10] =% ld \ n", tamaño de (SmartPhoneNames));
printf ("Tamaño de SmartPhonesPrice [10] =% ld \ n", tamaño de (SmartPhonesPrice));
return 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 entendamos el resultado.
Ahora, mirando el programa, 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 carácter = 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]
En el ejemplo-1, hemos visto que:
-
- El tamaño del carácter es de 1 byte
- El tamaño de un número entero es de 4 bytes
- El tamaño de un flotador es de 4 bytes
Por lo tanto, si sumamos el tamaño de todos los elementos de la estructura, deberíamos poder obtener el tamaño de la estructura, i.mi. Tipo de teléfono inteligente. 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 carácter, ocupan 4 bytes en lugar de 1 byte) asignados para la estructura debido al relleno de la estructura.
#incluir/ * Crea un tipo de estructura definido por el usuario - SmartPhoneType * /
struct SmartPhoneType
char sp_name;
int sp_version;
float sp_length;
float sp_width;
flotar sp_height;
SmartPhone;
/ * Definir un tipo de unión definido por el usuario - SmartPhoneUnionType * /
Union SmartPhoneUnionType
char sp_name;
int sp_version;
float sp_length;
float sp_width;
flotar sp_height;
SmartPhone_u;
int main ()
/ * Averigua el tamaño de estructura y unión * /
printf ("Tamaño de estructura =% ld \ n", tamaño de (SmartPhone));
printf ("Tamaño de unión =% ld \ n", tamaño de (SmartPhone_u));
return 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.
#incluirint main ()
/ * Declara char, int, float y variable y matriz de tipo doble * /
char var_a, var_b [20];
int var_c, var_d [20];
float var_e, var_f [20];
double var_g, var_h [20];
/ * Descubre el tamaño de las variables y la matriz.
Este programa demuestra que la variable también puede
ser utilizado como un operador de tamaño de operando * /
/ * 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", tamaño de (var_a));
printf ("Tamaño de var_b [20] =% ld \ n \ n", tamaño de (var_b));
/ * tamaño de int, int variable y int array * /
printf ("Tamaño de int =% ld \ n", sizeof (int));
printf ("Tamaño de var_c =% ld \ n", tamaño de (var_c));
printf ("Tamaño de var_d [20] =% ld \ n \ n", tamaño de (var_d));
/ * tamaño de flotante, variable flotante y matriz flotante * /
printf ("Tamaño de flotante =% ld \ n", tamaño de (flotante));
printf ("Tamaño de var_e =% ld \ n", tamaño de (var_e));
printf ("Tamaño de var_f [20] =% ld \ n \ n", tamaño de (var_f));
/ * tamaño de doble, doble variable y doble matriz * /
printf ("Tamaño de doble =% ld \ n", tamaño de (doble));
printf ("Tamaño de var_g =% ld \ n", tamaño de (var_g));
printf ("Tamaño de var_h [20] =% ld \ n", tamaño de (var_h));
return 0;
Sizeof para 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.
#incluirint 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", tamaño de (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 por una variable doble.
Por lo tanto, el operador sizeof devolverá el tamaño del tamaño máximo
variable i.mi. variable de tipo doble.* /
printf ("Tamaño de var_a * var_c =% ld \ n", sizeof (var_a * var_c));
return 0;
Uso práctico de sizeof (ejemplo6.C):
Este programa de ejemplo le 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;
float sp_length;
float sp_width;
flotar sp_height;
SmartPhoneType;
int main ()
/ * Asignar memoria en la memoria Heap para almacenar cinco SmartPhoneType
variables.
* /
SmartPhoneType * SmartPhone_Ptr = (SmartPhoneType *) malloc (5 * tamaño de (SmartPhoneType));
si (SmartPhone_Ptr != NULO)
printf ("Memoria asignada para 5 variables de estructura SmartPhoneType en
la memoria del montón.\norte");
demás
printf ("Ocurrió un error durante la asignación de memoria del montón!");
return 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, tipos de datos definidos por el usuario, expresiones, etc. en la memoria de la computadora. El operador Sizeof juega un papel importante en la asignación de memoria dinámica en C usando malloc, calloc, etc. en la memoria del montón.
