Sizeof Operator em C Language

Neste artigo, vamos aprender sobre o tamanho do operador em C. É um operador unário amplamente utilizado no desenvolvimento de software incorporado, o que nos ajuda a descobrir o tamanho do operando. Portanto, o valor de retorno do operador de tamanho do.

Entendendo o tamanho de:

Antes de mergulharmos na discussão do operador de tamanho, vamos primeiro entender o significado do operador. Um operador é representado por um token ou símbolo que é usado para executar uma operação como adição, subtração, multiplicação, divisão, etc. mediante valores ou variáveis ​​(operando). Por exemplo, " *" é o símbolo usado para representar a operação de multiplicação e funciona em dois operandos (resultado = a * b;). Este é um exemplo de operador binário.

No entanto, se um operador trabalhar em apenas um operando, chamamos um operador como um operador unário. O tamanho do operador é um dos operadores unários que existem na linguagem de programação C e, aparentemente, opera apenas em um operando. O tamanho do operador retorna o tamanho do operando. Isso significa que, desde o valor de retorno do operador de tamanho de, podemos dizer claramente quantos bytes alocados para manter o operando específico na memória.

A memória de um computador é uma coleção de unidades de memória (i.e. byte). Quando o sizeof (int) retorna quatro em um sistema de computador específico, podemos dizer que uma variável inteira obtém 4 bytes para manter seu valor na memória do sistema de computador específico. Além disso, observe que o valor de retorno do tamanho do operador também depende das máquinas que você está usando (sistema de 32 bits ou sistema de 64 bits).

Sintaxe:

Tamanho de (tipo)
Tamanho de (expressão)

O tipo de retorno de tamanho de é tamanho_t.

Exemplos:

Agora, como entendemos o tamanho do operador e conhecemos a sintaxe, vejamos alguns exemplos, o que nos ajudará a entender o conceito de uma maneira melhor.

• Tamanho de tipos internos (exemplo1.c)
• Sizeof for Array (exemplo2.c)
• Tamanho de tipos definidos pelo usuário (exemplo3.c)
• Tamanho de variáveis ​​(exemplo4.c)
• Tamanho de para expressão (exemplo5.c)
• Uso prático do tamanho do (exemplo6.c)

Tamanho de tipos internos (exemplo1.c):

Neste programa, veremos como o tamanho do operador funciona para tipos de dados internos, como int, char, flutuação, dupla. Vejamos o programa e a saída.

#incluir
int main ()

printf ("tamanho de char = %ld \ n", sizeof (char));
printf ("tamanho de int = %ld \ n", sizeof (int));
printf ("tamanho de float = %ld \ n", sizeof (float));
printf ("tamanho de duplo = %ld \ n \ n", sizeof (duplo));
printf ("tamanho de curto int = %ld \ n", sizeof (curto int));
printf ("tamanho de long int = %ld \ n", sizeof (longo int));
printf ("tamanho de longo longo int = %ld \ n", sizeof (longo interior));
printf ("Tamanho de Long Double = %LD \ n", Sizeof (Longo Double));
retornar 0;

Sizeof for Array (exemplo2.c)

Neste programa, veremos como usar o operador de tamanho de diferentes tipos de matriz. Em caso de uma matriz, o tamanho do operador retornará (não. de elementos na matriz * sizeof (tipo de matriz))). Por exemplo, quando declaramos uma matriz do tipo inteiro de 10 elementos (int smartphones [10];), o sizeof (smartphones) retornará:

(Não. de elementos em smartphones * sizeof (int)) = (10 * 4) = 40

Vejamos o programa e a saída.

#incluir
int main ()

int smartphones [10];
Char SmartphoneNames [10];
duplo smartphonesprice [10];
printf ("tamanho de int = %ld \ n", sizeof (int));
printf ("tamanho de char = %ld \ n", sizeof (char));
printf ("tamanho de duplo = %ld \ n", sizeof (duplo));
/* Descubra o tamanho de matriz*/
printf ("tamanho dos smartphones [10] = %ld \ n", sizeof (smartphones));
printf ("tamanho de smartphoneNames [10] = %ld \ n", sizeof (smartphoneNames));
printf ("tamanho do smartphonesprice [10] = %ld \ n", sizeof (smartphonesprice));
retornar 0;

Tamanho de tipos definidos pelo usuário (exemplo3.c):

Neste exemplo, veremos como usar o Sizeof Operator para tipos de dados definidos pelo usuário, como estrutura e união. Vamos usar o programa e entender a saída.

Agora, olhando para o programa, e podemos calcular manualmente o tamanho do smartphoneType. Como você pode ver abaixo, o smartphoneType é uma estrutura e contém os seguintes elementos:

• Número da variável do tipo de caractere = 1 [sp_name]
• Número da variável do tipo inteiro = 1 [sp_version]
• Número de variáveis ​​do tipo flutuante = 3 [SP_LENGLE, SP_WIDTH, SP_HEIGHT]

Do exemplo 1, vimos isso:

• • O tamanho do caractere é 1 byte
  • O tamanho de um número inteiro é de 4 bytes
  • O tamanho de um flutuador é de 4 bytes

Portanto, se somarmos o tamanho de todos os elementos da estrutura, deveríamos ser capazes de obter o tamanho da estrutura, eu.e. SmartphoneType. Portanto, o tamanho da estrutura deve ser = (1 + 4 + 4 + 4 + 4) bytes = 17 bytes. No entanto, a saída do programa diz que o tamanho da estrutura é 20. Os 3 bytes extras (sp_name, que é um personagem, estão pegando 4 bytes em vez de 1 byte) alocados para a estrutura devido ao preenchimento da estrutura.

#incluir
/* Crie um tipo de estrutura definido pelo usuário - smartphoneType*/
Struct smartphoneType

char sp_name;
int sp_version;
float sp_length;
flutuar sp_width;
flutuar SP_Height;
Smartphone;
/* Defina um tipo de união definido pelo usuário - smartphoneuniontype*/
Union SmartphoneUnioType

char sp_name;
int sp_version;
float sp_length;
flutuar sp_width;
flutuar SP_Height;
Smartphone_u;
int main ()

/* Descubra o tamanho da estrutura e união*/
printf ("tamanho da estrutura = %ld \ n", sizeof (smartphone));
printf ("tamanho da união = %ld \ n", sizeof (smartphone_u));
retornar 0;

Tamanho de variáveis ​​(exemplo4.c):

Este programa de exemplo ilustra que o tamanho do operador é capaz de aceitar a variável também e retornar o tamanho da variável.

#incluir
int main ()

/ * Declare Char, Int, Float e Double Type Variable and Array */
char var_a, var_b [20];
int var_c, var_d [20];
flutuar var_e, var_f [20];
duplo var_g, var_h [20];
/* Descubra o tamanho de variáveis ​​e matriz.
Este programa demonstra que a variável também pode
ser usado como um tamanho de operador do operador*/
/* Tamanho de Char, Char Variable e Char Array*/
printf ("tamanho de char = %ld \ n", sizeof (char));
printf ("tamanho de var_a = %ld \ n", sizeof (var_a));
printf ("tamanho de var_b [20] = %ld \ n \ n", sizeof (var_b));
/* Tamanho de int, int variável e int matriz*/
printf ("tamanho de int = %ld \ n", sizeof (int));
printf ("tamanho de var_c = %ld \ n", sizeof (var_c));
printf ("tamanho de var_d [20] = %ld \ n \ n", sizeof (var_d));
/* Tamanho da flutuação, variável flutuante e matriz de flutuação*/
printf ("tamanho de float = %ld \ n", sizeof (float));
printf ("tamanho de var_e = %ld \ n", sizeof (var_e));
printf ("tamanho de var_f [20] = %ld \ n \ n", sizeof (var_f));
/* Tamanho de variável dupla, dupla e matriz dupla*/
printf ("tamanho de duplo = %ld \ n", sizeof (duplo));
printf ("tamanho de var_g = %ld \ n", sizeof (var_g));
printf ("tamanho de var_h [20] = %ld \ n", sizeof (var_h));
retornar 0;

Tamanho de para expressão (exemplo5.c):

Neste programa de exemplo, demonstraremos que o tamanho do operador também pode aceitar uma expressão e retornar o tamanho da expressão resultante.

#incluir
int main ()

int var_a = 5, var_b = 3;
duplo var_c = 2.5, var_d = 4.5;
printf ("tamanho de int = %ld \ n", sizeof (int));
printf ("tamanho de duplo = %ld \ n \ n", sizeof (duplo));
printf ("tamanho de var_a * var_b = %ld \ n", sizeof (var_a * var_b));
printf ("tamanho de var_c * var_d = %ld \ n", sizeof (var_c * var_d));
/* Aqui estamos multiplicando uma variável inteira com uma variável dupla.
Portanto, o tamanho do operador retornará o tamanho do tamanho máximo
variável i.e. Variável de tipo duplo.*/
printf ("tamanho de var_a * var_c = %ld \ n", sizeof (var_a * var_c));
retornar 0;

Uso prático do tamanho do (exemplo6.c):

Este programa de exemplo o ajudará a entender um caso de uso prático do operador de tamanho de. O tamanho do operador é muito útil ao alocar a memória dinâmica do Heap usando o Malloc. Vejamos o programa e a saída.

#incluir
#incluir
typedef struct

char sp_name;
int sp_version;
float sp_length;
flutuar sp_width;
flutuar SP_Height;
SmartphoneType;
int main ()

/* ALOCAR MEMÓRIR
variáveis.
*/
SmartphoneType * smartphone_ptr = (smartphoneType *) malloc (5 * sizeof (smartphoneType));
if (smartphone_ptr != Nulo)

printf ("Memória alocada para 5 variáveis ​​de estrutura smartphoneType
a memória da heap.\ n ");

outro

Printf ("Ocorreu o erro durante a alocação de memória da heap!");

retornar 0;

Conclusão:

O tamanho de é um importante operador unário na linguagem de programação C. Isso nos ajuda a determinar o tamanho dos tipos de dados primitivos, tipos de dados definidos pelo usuário, expressões, etc. na memória do computador. O tamanho do operador desempenha um papel importante na alocação de memória dinâmica em C usando o MALLOC, Calloc, etc. Na memória da heap.