Phenquestions
Comprensione delle dimensioni di:
Prima di immergerci nella discussione sulla dimensione dell'operatore, cerchiamo prima di capire il significato dell'operatore. Un Operatore è rappresentato da un token o 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 un operatore unario. L'operatore sizeof è uno degli operatori unari che esistono nel linguaggio di programmazione C e apparentemente opera solo su un operando. L'operatore sizeof restituisce la dimensione dell'operando. Ciò significa che, dal valore restituito dall'operatore Sizeof, possiamo chiaramente dire quanti byte allocati per contenere il particolare operando nella memoria del computer.
La memoria di un computer è un insieme di unità di memoria (i.e. byte). Quando sizeof (int) restituisce quattro in un particolare sistema informatico, possiamo dire che una variabile intera impiega 4 byte per mantenere il suo valore nella memoria di quel computer specifico. Inoltre, tieni presente che il valore restituito dall'operatore sizeof dipende anche dalle macchine che stai utilizzando (sistema a 32 bit o sistema a 64 bit).
Sintassi:
Dimensione di (tipo)Dimensione di (espressione)
Il tipo restituito da sizeof è size_t.
Esempi:
Ora poiché comprendiamo l'operatore sizeof e conosciamo la sintassi, diamo un'occhiata a un paio di esempi, che ci aiuteranno a capire meglio il concetto.
- Sizeof per i tipi incorporati (esempio1.c)
- Sizeof per Array (esempio2.c)
- Sizeof per i tipi definiti dall'utente (esempio3.c)
- Sizeof per le variabili (esempio4.c)
- Sizeof per l'espressione (esempio5.c)
- Uso pratico di sizeof (esempio6.c)
Sizeof per i tipi incorporati (esempio1.c):
In questo programma vedremo come funziona l'operatore sizeof per tipi di dati incorporati come int, char, float, double. Diamo un'occhiata al programma e all'output.
#includereintero principale()
printf("Dimensione di char = %ld \n", sizeof(char));
printf("Dimensione di int = %ld \n", sizeof(int));
printf("Dimensione float = %ld \n", sizeof(float));
printf("Dimensione di double = %ld \n\n", sizeof(double));
printf("Dimensione di short int = %ld \n", sizeof(short int));
printf("Dimensione di long int = %ld \n", sizeof(long int));
printf("Dimensione di long long int = %ld \n", sizeof(long long int));
printf("Dimensione del doppio lungo = %ld \n", sizeof(doppio lungo));
restituisce 0;
Sizeof per Array (esempio2.c)
In questo programma vedremo come utilizzare l'operatore sizeof per diversi tipi di array. Nel caso di un array, l'operatore sizeof restituirà (No. di elementi nell'array * Sizeof (tipo di array)). Ad esempio, quando dichiariamo un array di tipo intero di 10 elementi (int SmartPhones [10] ;), sizeof(Smartphones) restituirà:
(No. di elementi negli smartphone * sizeof(int)) = (10 * 4) = 40Diamo un'occhiata al programma e all'output.
#includereintero principale()
smartphone int[10];
char SmartPhoneNames[10];
prezzo doppio smartphone[10];
printf("Dimensione di int = %ld \n", sizeof(int));
printf("Dimensione di char = %ld \n", sizeof(char));
printf("Dimensione di double = %ld \n", sizeof(double));
/* Scopri la dimensione dell'array*/
printf("Dimensione smartphone[10] = %ld \n", sizeof(SmartPhone));
printf("Dimensione dei nomi degli smartphone[10] = %ld \n", sizeof(nomi degli smartphone));
printf("Dimensione di SmartPhonesPrice[10] = %ld \n", sizeof(SmartPhonesPrice));
restituisce 0;
Sizeof per i 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, possiamo calcolare manualmente la dimensione di SmartPhoneType. Come puoi vedere di seguito, SmartPhoneType è una struttura e contiene i seguenti elementi:
- Numero di variabili di tipo carattere = 1 [sp_name]
- Numero di variabili di tipo intero = 1 [sp_version]
- Numero di variabili di tipo float= 3 [sp_length, sp_width, sp_height]
Dall'esempio-1, abbiamo visto che:
-
- La dimensione del carattere è 1 byte
- La dimensione di un numero intero è 4 byte
- La dimensione di un float è 4 byte
Pertanto, se sommiamo la dimensione di tutti gli elementi nella struttura, dovremmo essere in grado di ottenere la dimensione della struttura, i.e. Tipo di smartphone. Pertanto, la dimensione della struttura dovrebbe essere = (1 + 4 + 4 + 4 + 4) byte = 17 byte. Tuttavia, l'output del programma dice che la dimensione della struttura è 20. I 3 byte aggiuntivi (sp_name, che è un carattere, occupano 4 byte invece di 1 byte) allocati per la struttura a causa del riempimento della struttura.
#includere/* Crea un tipo di struttura definito dall'utente - SmartPhoneType*/
struct SmartPhoneType
char nome_sp;
int sp_version;
float sp_length;
float sp_width;
float sp_height;
Smartphone;
/* Definisce un tipo di unione definito dall'utente - SmartPhoneUnionType*/
Union SmartPhoneUnionType
char nome_sp;
int sp_version;
float sp_length;
float sp_width;
float sp_height;
SmartPhone_u;
intero principale()
/* Scopri la dimensione della struttura e dell'unione*/
printf("Dimensione della struttura = %ld \n", sizeof(SmartPhone));
printf("Dimensione dell'unione = %ld \n", sizeof(SmartPhone_u));
restituisce 0;
Sizeof per le variabili (esempio4.c):
Questo programma esempio illustra che l'operatore sizeof è in grado di accettare anche la variabile e restituire la dimensione della variabile.
#includereintero principale()
/* Dichiara char, int, float e double type variabile e array */
char var_a, var_b[20];
int var_c, var_d[20];
float var_e, var_f[20];
doppio var_g, var_h[20];
/* Scopri la dimensione delle variabili e dell'array.
Questo programma dimostra che la variabile può anche
essere usato come operando sizeof operator*/
/* dimensione di char, variabile char e array di caratteri*/
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, variabile int 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 di float, variabile float e array float*/
printf("Dimensione 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 di double, double variabile e double array*/
printf("Dimensione di double = %ld \n", sizeof(double));
printf("Dimensione di var_g = %ld \n", sizeof(var_g));
printf("Dimensione di var_h[20] = %ld \n", sizeof(var_h));
restituisce 0;
Sizeof per l'espressione (esempio5.c):
In questo programma di esempio, dimostreremo che l'operatore sizeof può anche accettare un'espressione e restituire la dimensione dell'espressione risultante.
#includereintero principale()
int var_a = 5, var_b = 3;
doppia var_c = 2.5, var_d = 4.5;
printf("Dimensione di int = %ld \n", sizeof(int));
printf("Dimensione del 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 per una doppia variabile.
Pertanto, l'operatore sizeof restituirà la dimensione della dimensione massima
variabile i.e. variabile di tipo doppio.*/
printf("Dimensione di var_a * var_c = %ld \n", sizeof(var_a * var_c));
restituisce 0;
Uso pratico di sizeof (esempio6.c):
Questo programma di esempio ti aiuterà a capire un caso d'uso pratico dell'operatore sizeof. L'operatore Sizeof è molto utile durante l'allocazione della memoria dinamica dall'heap usando malloc. Diamo un'occhiata al programma e all'output.
#includere#includere
struttura typedef
char nome_sp;
int sp_version;
float sp_length;
float sp_width;
float sp_height;
Tipo Smartphone;
intero principale()
/* Alloca memoria nella memoria Heap per contenere cinque SmartPhoneType
variabili.
*/
SmartPhoneType * SmartPhone_Ptr = (SmartPhoneType *)malloc(5 * sizeof(SmartPhoneType));
if(SmartPhone_Ptr != NULLO)
printf("Memoria allocata per 5 variabili di struttura SmartPhoneType in
la memoria Heap.\n");
altro
printf("Si è verificato un errore durante l'allocazione della memoria heap!");
restituisce 0;
Conclusione:
Il Sizeof è un importante operatore unario nel linguaggio di programmazione C. Ci aiuta a determinare la dimensione dei tipi di dati primitivi, tipi di dati definiti dall'utente, espressioni, ecc. nella memoria del computer. L'operatore Sizeof svolge un ruolo importante nell'allocare la memoria dinamica in C usando malloc, calloc, ecc. nella memoria dell'heap.
