C ++ sizeof

La dimensione di () è un operatore in C++. È un operatore unario che aiuta i programmatori a determinare le dimensioni degli operandi che stanno usando. Un tipo integrale, tipicamente indicato dalla dimensione "t", è il risultato di questo operatore. Questo operatore viene in genere utilizzato con tipi di dati primitivi come intero, galleggiante, puntatore, ecc. Inoltre, può fornire la dimensione di tipi di dati più sofisticati come sindacati e strutture. È un operatore in grado di calcolare la dimensione dell'operando e determinare la dimensione di qualsiasi tipo di dati al momento della compilazione. La dimensione è la quantità di RAM utilizzata dal computer ed è determinata dall'operazione di dimensione ().

Sintassi dell'operatore sizeof () in C++

Quanto segue descrive la sintassi dell'operatore sizeof ():

# sizeof (nome di data_type);

Se utilizzato con il primo tipo di oggetto, la funzione sizeof () emette la dimensione dell'oggetto in byte per il tipo di oggetto che viene inviato. La dimensione dell'articolo che si trova nel tipo di espressione, misurata in byte, è il secondo tipo. Dopo la valutazione dell'espressione, la dimensione rimane la stessa.

Esempio 1:

Quando i tipi di dati come INT, FLOAT, CHAR, ecc. sono utilizzati con l'operatore sizeof (), la funzione fornisce semplicemente la quantità di RAM assegnata a quel particolare tipo di dati.

#includere
Utilizzo dello spazio dei nomi std;
int main ()

std :: cout << "Size of data type int : " <std :: cout << "Size of data type float : " <std :: cout << "Size of data type double: " <std :: cout << "Size of data type char: " <restituzione 0;

Utilizzando l'operatore sizeof () con il comando Cout, valutiamo la dimensione dei tipi di dati integrati nell'applicazione sopra menzionata. Come possiamo vedere nella seguente uscita, la dimensione () l'operazione produce la stessa risposta che ci aspetteremmo date la nostra conoscenza delle dimensioni del byte di int, galleggiante, doppio e char.

Esempio 2:

Il programma, quando un tipo di classe è operando, utilizza l'operatore di dimensione (). Ecco un'illustrazione:

#includere
Utilizzo dello spazio dei nomi std;
Classe mybase_class

int x;
;
int main ()

Mybase_class y;
std :: cout << "Size of Base class is : "<restituzione 0;

Con una sola variabile intera "x" nella classe "mybase_class" e il suddetto metodo principale dello script, valutiamo le dimensioni della classe. Innanzitutto, chiamiamo la classe data e creiamo il suo oggetto come "y". Quindi, abbiamo un operatore sizeof () che prende "y" come input. Le variabili interi occupano 4 byte, quindi il risultato sarebbe 4 byte stampato nel seguente:

Esempio 3:

Se aumentiamo il numero di variabili interi in una classe, viene prodotto il seguente codice:

#includere
Utilizzo dello spazio dei nomi std;
Classe myclass_base

int i;
int j;
;
int main ()

Myclass_base J;
std :: cout << "Size of MyClass_Base is : "<restituzione 0;

Ora c'è una seconda variabile intera "J" nel codice precedente. Dato che la variabile INT occupa 4 byte e ci sono due variabili Integer come "io" e "j", la classe "myclass_base" in questo scenario ha una dimensione di 8 byte.

Esempio 4:

Il codice potrebbe assomigliare a quanto segue se includiamo una variabile Char:

#includere
Utilizzo dello spazio dei nomi std;
Classe Myclass

int p;
int q;
Char Ch;
;
int main ()

Myclass Q;
std :: cout << "Size of MyClass is : "<restituzione 0;

Due numeri interi e una variabile Char sono usati nel codice precedente della classe "Myclass". La dimensione della classe dovrebbe essere 9 byte in quanto esistono tre tipi di dati (int+int+char) secondo i nostri calcoli. Ma questo non è corretto a causa dell'idea di imbottitura della struttura. Puoi vedere il seguente valore del risultato:

Esempio 5:

Il caso in cui l'operando è un array. Diamo un'occhiata all'implementazione del programma:

#includere
Utilizzo dello spazio dei nomi std;
int main ()

int arr_set [] = 5,15,25,35,45;
std :: cout << "Size of the 'arr_set' is : "<restituzione 0;

Abbiamo istituito un array di tipo intero come "arr_set" con cinque elementi nel programma precedente. Abbiamo determinato la dimensione dell'array usando l'operatore sizeof (). L'array ha una dimensione di 20 byte, poiché il tipo di dati INT occupa 4 byte e ci sono 5 voci nell'array, che rendono un bisogno di spazio di memoria totale di 5 * 4 = 20 byte. Come possiamo vedere nella seguente uscita, l'operazione sizeof () ha prodotto lo stesso risultato.

Esempio 6:

L'esempio prende già le dimensioni dell'array. Consideriamo un array da una prospettiva particolare.

#includere
Utilizzo dello spazio dei nomi std;
void new_function (int array [])

std :: cout << "Size of array is : " <
int main ()

int array [] = 51,52,53,54,55;
new_function (array);
restituzione 0;

Abbiamo provato a utilizzare la funzione "new_function" nell'applicazione sopra menzionata per stampare la dimensione dell'array. Abbiamo formato un array di tipo intero in questa istanza e inviamo il parametro "array" al new_function (). La dimensione del puntatore intero o int* viene restituita da new_function (). Nei sistemi operativi a 64 bit, la dimensione di Int* è 8 byte. L'output genera la dimensione dell'array come segue:

Esempio 7:

Ora, questo è l'esempio in cui l'argomento è del tipo di puntatore all'interno dell'operatore sizeof ().

#includere
Utilizzo dello spazio dei nomi std;
int main ()

int *ptr1 = new int (31);
std :: cout << "ptr1 size:" <std :: cout << "*ptr1 size :" <doppio *ptr2 = nuovo doppio (20.99);
std :: cout <<"ptr2 size :" <std :: cout <<" *ptr2 size :"<char *ptr3 = new char ('m');
std :: cout <<"ptr3 size :" <std :: cout <<"*ptr3 size :"<restituzione 0;

Abbiamo calcolato la dimensione dei puntatori nella sceneggiatura menzionata in precedenza. Per i tipi di dati "int", "doppio" e "char", le dimensioni del puntatore rimangono costanti. La dimensione del puntatore è di 4 byte se il computer aveva un sistema operativo a 32 bit. La dimensione del puntatore è di 8 byte se il computer esegue un sistema operativo a 64 bit. Il risultato è 8 byte mentre eseguiamo questo script su una piattaforma a 64 bit. Ora, se diamo al puntatore il simbolo "*", l'uscita cambia in base al tipo di dati. Ad esempio, se *ptr1 è un tipo intero, l'operatore sizeof () fornisce 4 byte perché un tipo di dati INT occupa 4 byte. Quanto segue è la dimensione risultante dei puntatori corrispondenti a ciascun tipo di dati specificato:

Esempio 8:

L'esempio in cui abbiamo un'espressione come operatore di dimensione () operatore.

#includere
Utilizzo dello spazio dei nomi std;
int main ()

int Integer_1;
double integer_2;
cout << "size of int and double: " <restituzione 0;

Abbiamo due variabili, Integer_1 e Integer_2, rispettivamente di INT e doppi tipi. Sono dichiarati nel programma. Come sappiamo, i numeri interi hanno 4 byte di dimensioni mentre i doppi sono 8 byte. Li abbiamo aggiunti entrambi nell'operatore sizeof (). La variabile, doppia con una dimensione di 8 byte, è il risultato.

Conclusione

Una spiegazione di dimensione di) per C ++ termina qui. Abbiamo superato i dettagli su come funziona l'operatore C ++ sizeof (), insieme a esempi pertinenti. Qualsiasi tipo di dati, espressione, array, ecc. può avere le sue dimensioni determinate usando l'operatore sizeof (). Il tipo di dati o un'espressione devono essere forniti come parte dell'argomento. E la funzione restituisce la dimensione di quel tipo di dati in byte come risultato.