Sizeof operatore in lingua c

In questo articolo, impareremo sull'operatore di dimensioni in C. È un operatore unario ampiamente utilizzato nello sviluppo del software incorporato, che ci aiuta a scoprire le dimensioni dell'operando. Pertanto, il valore di restituzione dell'operatore sizeof ci aiuta a comprendere il numero di byte allocati nella memoria del computer per contenere la variabile particolare o il tipo di dati.

Comprensione delle dimensioni di:

Prima di immergerci nella discussione dell'operatore, capiamo prima il significato dell'operatore. Un operatore è rappresentato da un token o un simbolo che viene utilizzato per eseguire un'operazione come addizione, sottrazione, moltiplicazione, divisione, ecc. su valori o variabili (operandi). Ad esempio, " *" è il simbolo che viene utilizzato per rappresentare l'operazione di moltiplicazione e funziona su due operandi (risultato = A * B;). Questo è un esempio di operatore binario.

Tuttavia, se un operatore lavora su un solo operando, chiamiamo tale operatore come operatore unario. L'operatore sizeof è uno degli operatori unari che esistono nel linguaggio di programmazione C e apparentemente opera solo su un operando. La dimensione dell'operatore restituisce le dimensioni dell'operando. Ciò significa che, dal valore di restituzione dell'operatore di dimensione, possiamo chiaramente dire quanti byte hanno assegnato per trattenere il particolare operando nella memoria del computer.

La memoria di un computer è una raccolta di unità di memoria (i.e. byte). Quando sizeof (int) ne restituisce quattro in un particolare sistema informatico, possiamo dire che una variabile intera richiede 4 byte per mantenere il suo valore nella memoria di quel sistema informatico specifico. Inoltre, si noti che il valore di restituzione dell'operatore sizeof dipende anche dalle macchine che si stanno utilizzando (sistema a 32 bit o sistema a 64 bit).

Sintassi:

Sizeof (tipo)
Sizeof (espressione)

Il tipo di ritorno di dimensione è size_t.

Esempi:

Ora, dal momento che comprendiamo l'operatore di dimensioni e conosciamo la sintassi, diamo un'occhiata a un paio di esempi, che ci aiuteranno a comprendere il concetto in un modo migliore.

• Sizeof per i tipi integrati (Esempio1.C)
• Sizeof per array (esempio2.C)
• Sizeof per tipi definiti dall'utente (Esempio3.C)
• Sizeof per le variabili (Esempio4.C)
• Sizeof per espressione (esempio5.C)
• Uso pratico di dimensioni di (Esempio6.C)

Sizeof per i tipi integrati (Esempio1.C):

In questo programma vedremo come funziona l'operatore di dimensione per tipi di dati integrati come int, char, galleggiante, doppio. Vediamo il programma e l'output.

#includere
int main ()

printf ("dimensione di char = %ld \ n", sizeof (char));
printf ("dimensione di int = %ld \ n", sizeof (int));
printf ("dimensione di float = %ld \ n", sizeof (float));
printf ("dimensione di doppio = %ld \ n \ n", sizeof (doppio));
printf ("dimensione del corto int = %ld \ n", sizeof (corto int));
printf ("dimensione di long int = %ld \ n", sizeof (long int));
printf ("dimensioni di lunghe lunghe int = %ld \ n", sizeof (lungo lungo));
printf ("dimensione del doppio lungo = %ld \ n", sizeof (lungo doppio));
restituzione 0;

Sizeof per array (esempio2.C)

In questo programma, vedremo come utilizzare l'operatore di dimensioni per diversi tipi di array. In caso di un array, l'operatore size di tornerà (no. di elementi nell'array * sizeof (tipo di array)). Ad esempio, quando dichiariamo un array di tipi interi di 10 elementi (int smartphone [10];), la dimensione (smartphone) tornerà:

(NO. di elementi negli smartphone * sizeof (int)) = (10 * 4) = 40

Vediamo il programma e l'output.

#includere
int main ()

smartphone int [10];
Char Smartphonenames [10];
Double SmartphonesPrice [10];
printf ("dimensione di int = %ld \ n", sizeof (int));
printf ("dimensione di char = %ld \ n", sizeof (char));
printf ("dimensione di doppio = %ld \ n", sizeof (doppio));
/* Scopri la dimensione dell'array*/
printf ("dimensione degli smartphone [10] = %ld \ n", sizeof (smartphone));
printf ("dimensioni di smartphonenames [10] = %ld \ n", sizeof (smartphonenames));
printf ("dimensione di smartphonesprice [10] = %ld \ n", sizeof (smartphonesprice));
restituzione 0;

Sizeof per tipi definiti dall'utente (Esempio3.C):

In questo esempio, vedremo come utilizzare l'operatore sizeof per i tipi di dati definiti dall'utente come struttura e unione. Usiamo il programma e comprendiamo l'output.

Ora, guardando il programma e possiamo calcolare manualmente le dimensioni di SmartphoneType. Come puoi vedere di seguito, SmartphoneType è una struttura e contiene i seguenti elementi:

• Numero di variabile tipo di carattere = 1 [SP_NAME]
• Numero di variabile tipo intero = 1 [sp_version]
• Numero di variabili di tipo float = 3 [SP_LENGTLE, SP_WIDTH, SP_HEIGHT]

Dall'esempio-1, l'abbiamo visto:

• • La dimensione del carattere è 1 byte
  • La dimensione di un numero intero è di 4 byte
  • La dimensione di un galleggiante è di 4 byte

Pertanto, se aggiungiamo le dimensioni di tutti gli elementi della struttura, dovremmo essere in grado di ottenere le dimensioni della struttura, i.e. Smartphonetype. Pertanto, la dimensione della struttura dovrebbe essere = (1 + 4 + 4 + 4 + 4) byte = 17 byte. Tuttavia, l'output del programma afferma che la dimensione della struttura è 20. I 3 byte extra (sp_name, che è un personaggio, stanno prendendo 4 byte anziché 1 byte) allocati per la struttura a causa della struttura di imbottitura.

#includere
/* Crea un tipo di struttura definita dall'utente - SmartphoneType*/
Struttura SmartPhoneType

char sp_name;
int sp_version;
float sp_length;
float sp_width;
float sp_height;
Smartphone;
/* Definisci un tipo di unione definito dall'utente - smartphoneuniontype*/
Union SmartphoneNionType

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

/* Scopri le dimensioni della struttura e dell'unione*/
printf ("dimensione di struct = %ld \ n", sizeof (smartphone));
printf ("dimensione di unione = %ld \ n", sizeof (smartphone_u));
restituzione 0;

Sizeof per le variabili (Esempio4.C):

Questo programma di esempio illustra che l'operatore sizeof è in grado di accettare anche la variabile e restituire la dimensione della variabile.

#includere
int main ()

/ * Dichiara Char, Int, Float e Doppio tipo e array */
char var_a, var_b [20];
int var_c, var_d [20];
float var_e, var_f [20];
double var_g, var_h [20];
/* Scopri la dimensione di variabili e array.
Questo programma dimostra che anche la variabile può
essere utilizzato come operatore operativo di operatore*/
/* Dimensione di char, variabile char e array char*/
printf ("dimensione di char = %ld \ n", sizeof (char));
printf ("dimensione di var_a = %ld \ n", sizeof (var_a));
printf ("dimensione di var_b [20] = %ld \ n \ n", sizeof (var_b));
/* Dimensione di int, int variabile e array int*/
printf ("dimensione di int = %ld \ n", sizeof (int));
printf ("dimensione di var_c = %ld \ n", sizeof (var_c));
printf ("dimensione di var_d [20] = %ld \ n \ n", sizeof (var_d));
/* Dimensione del galleggiante, variabile float e array float*/
printf ("dimensione di float = %ld \ n", sizeof (float));
printf ("dimensione di var_e = %ld \ n", sizeof (var_e));
printf ("dimensione di var_f [20] = %ld \ n \ n", sizeof (var_f));
/* Dimensione del doppio, doppio variabile e doppio array*/
printf ("dimensione di doppio = %ld \ n", sizeof (doppio));
printf ("dimensione di var_g = %ld \ n", sizeof (var_g));
printf ("dimensione di var_h [20] = %ld \ n", sizeof (var_h));
restituzione 0;

Sizeof per espressione (esempio5.C):

In questo programma di esempio, dimostreremo che l'operatore size del operatore può anche accettare un'espressione e restituire le dimensioni dell'espressione risultante.

#includere
int main ()

int var_a = 5, var_b = 3;
doppio var_c = 2.5, var_d = 4.5;
printf ("dimensione di int = %ld \ n", sizeof (int));
printf ("dimensione di doppio = %ld \ n \ n", sizeof (doppio));
printf ("dimensione di var_a * var_b = %ld \ n", sizeof (var_a * var_b));
printf ("dimensione di var_c * var_d = %ld \ n", sizeof (var_c * var_d));
/* Qui stiamo moltiplicando una variabile intera con una doppia variabile.
Pertanto, l'operatore sizeof restituirà la dimensione delle dimensioni massime
variabile i.e. variabile a doppio tipo.*/
printf ("dimensione di var_a * var_c = %ld \ n", sizeof (var_a * var_c));
restituzione 0;

Uso pratico di dimensioni di (Esempio6.C):

Questo programma di esempio ti aiuterà a comprendere un caso d'uso pratico dell'operatore di dimensioni. L'operatore sizeof è molto utile durante l'allocazione della memoria dinamica da heap usando Malloc. Vediamo il programma e l'output.

#includere
#includere
typedef struct

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

/* Allocati la memoria nella memoria heap per contenere cinque smartphoneType
variabili.
*/
SmartphoneType * smartphone_ptr = (smartphoneType *) malloc (5 * sizeof (smartphoneType));
if (smartphone_ptr != Null)

printf ("Memoria allocata per 5 variabili di struttura smartphoneType in
la memoria del heap.\N");

altro

printf ("Errore si è verificato durante l'allocazione della memoria heap!");

restituzione 0;

Conclusione:

La dimensione è un importante operatore unario nel linguaggio di programmazione C. Ci aiuta a determinare la dimensione dei tipi di dati primitivi, i tipi di dati definiti dall'utente, le espressioni, ecc. nella memoria del computer. L'operatore sizeof svolge un ruolo importante nell'allocazione della memoria dinamica in C usando Malloc, Calloc, ecc. Nella memoria del heap.